@@ -322,6 +322,10 @@
    list(APPEND PLATFORM_TARGET_FILES
            "${QEMU_DBUS_GENERATED_DIR}/dbus-display1.c"
            "${QEMU_DBUS_GENERATED_DIR}/dbus-display1.h"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/audio.h"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/audio.cpp"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/audio_mixer.h"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/audio_mixer.cpp"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/capture.cpp"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/frame_store.h"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/frame_store.cpp"

@@ -2230,6 +2230,9 @@
            With `-display dbus,gl=on` QEMU sends GPU buffers (DMABUF) that VAAPI, NVENC and Vulkan encode
            without a copy; QEMU must render on the same GPU, so match QEMU's `rendernode=` with
            [adapter_name](#adapter_name).
            The guest's sound is streamed too when QEMU plays it to D-Bus: start QEMU with
            `-audiodev dbus,id=snd0`, a sound device such as `-device intel-hda -device hda-output,audiodev=snd0`,
            and `-display dbus,audiodev=snd0`. Sunshine's audio sink settings don't apply to a VM.
            @note{Applies to Linux only.}</td>
    </tr>
    <tr>

@@ -672,10 +672,21 @@
    };
  }  // namespace pa
#ifdef SUNSHINE_BUILD_QEMU
  std::unique_ptr<audio_control_t> qemu_audio_control();
#endif
  /**
   * @brief Create the platform audio controller.
   */
  std::unique_ptr<audio_control_t> audio_control() {
#ifdef SUNSHINE_BUILD_QEMU
    // a VM's audio comes from QEMU's D-Bus display, not from a PulseAudio sink
    if (config::video.capture == "qemu") {
      return qemu_audio_control();
    }
#endif
    auto audio = std::make_unique<pa::server_t>();
    if (audio->init()) {

@@ -1,0 +1,317 @@
/**
 * @file src/platform/linux/qemu/audio.cpp
 * @brief Definitions for streaming a QEMU guest's audio output (`capture = qemu`).
 */
// class header include
#include "audio.h"
// standard includes
#include <algorithm>
#include <atomic>
#include <map>
#include <optional>
// local includes
#include "src/config.h"
#include "src/logging.h"
using namespace std::literals;
namespace qemu {
  namespace {
    constexpr auto sample_timeout = 100ms;  ///< Longest a microphone read waits before the pipeline checks for shutdown.
  }  // namespace
  /**
   * @brief Receives QEMU's audio calls, remembers the stream state and forwards everything to the attached mixers.
   */
  class audio_hub_t: public audio_out_listener_t {
  public:
    void init(std::uint64_t id, const pcm_format_t &format) override {
      std::lock_guard lock {mutex};
      BOOST_LOG(info) << "qemu: guest audio stream "sv << id << ": "sv << to_string(format);
      streams[id] = stream_state_t {format};
      for (const auto &mixer : mixers) {
        mixer->init(id, format);
      }
    }
    void fini(std::uint64_t id) override {
      std::lock_guard lock {mutex};
      BOOST_LOG(debug) << "qemu: guest audio stream "sv << id << " closed"sv;
      streams.erase(id);
      for (const auto &mixer : mixers) {
        mixer->fini(id);
      }
    }
    void set_enabled(std::uint64_t id, bool enabled) override {
      std::lock_guard lock {mutex};
      if (auto it = streams.find(id); it != streams.end()) {
        it->second.enabled = enabled;
      }
      for (const auto &mixer : mixers) {
        mixer->set_enabled(id, enabled);
      }
    }
    void set_volume(std::uint64_t id, bool mute, std::span<const std::uint8_t> volume) override {
      std::lock_guard lock {mutex};
      if (auto it = streams.find(id); it != streams.end()) {
        it->second.volume = std::make_pair(mute, std::vector<std::uint8_t>(volume.begin(), volume.end()));
      }
      for (const auto &mixer : mixers) {
        mixer->set_volume(id, mute, volume);
      }
    }
    void write(std::uint64_t id, std::span<const std::uint8_t> data) override {
      std::lock_guard lock {mutex};
      for (const auto &mixer : mixers) {
        mixer->write(id, data);
      }
    }
    void disconnected() override {
      std::lock_guard lock {mutex};
      connected = false;
      streams.clear();
      for (const auto &mixer : mixers) {
        mixer->close();
      }
    }
    /**
     * @brief Start feeding a mixer, replaying the current streams first.
     *
     * @param mixer Mixer to feed.
     */
    void attach(const std::shared_ptr<audio_mixer_t> &mixer) {
      std::lock_guard lock {mutex};
      if (!connected) {
        mixer->close();
      }
      for (const auto &[id, stream] : streams) {
        mixer->init(id, stream.format);
        mixer->set_enabled(id, stream.enabled);
        if (stream.volume) {
          mixer->set_volume(id, stream.volume->first, stream.volume->second);
        }
      }
      mixers.push_back(mixer);
    }
    /**
     * @brief Stop feeding a mixer.
     *
     * @param mixer Mixer to remove.
     */
    void detach(const std::shared_ptr<audio_mixer_t> &mixer) {
      std::lock_guard lock {mutex};
      std::erase(mixers, mixer);
    }
    /**
     * @brief Report whether QEMU still has the listener connection open.
     *
     * @return False after `disconnected()`.
     */
    [[nodiscard]] bool is_connected() const {
      std::lock_guard lock {mutex};
      return connected;
    }
  private:
    /**
     * @brief What a newly attached mixer needs to know about a stream.
     */
    struct stream_state_t {
      pcm_format_t format;  ///< PCM layout.
      bool enabled {true};  ///< Last SetEnabled value.
      std::optional<std::pair<bool, std::vector<std::uint8_t>>> volume;  ///< Last SetVolume mute flag and volumes.
    };
    mutable std::mutex mutex;  ///< Guards everything below; held while forwarding so calls stay ordered.
    std::map<std::uint64_t, stream_state_t> streams;  ///< Streams by id.
    std::vector<std::shared_ptr<audio_mixer_t>> mixers;  ///< Attached mixers.
    bool connected {true};  ///< Whether the listener connection is open.
  };
  std::shared_ptr<audio_output_t> audio_output_t::connect(std::shared_ptr<session_t> session) {
    if (!session) {
      return nullptr;
    }
    auto hub = std::make_shared<audio_hub_t>();
    auto registration = session->register_audio_out_listener(hub);
    if (!registration) {
      return nullptr;
    }
    std::shared_ptr<audio_output_t> output {new audio_output_t {}};
    output->session = std::move(session);
    output->hub = std::move(hub);
    output->registration = std::move(registration);
    return output;
  }
  audio_output_t::~audio_output_t() {
    // unregister first, so no call reaches the hub while it is destroyed
    registration.reset();
  }
  bool audio_output_t::alive() const {
    return session->alive() && hub->is_connected();
  }
  std::shared_ptr<audio_mixer_t> audio_output_t::attach(std::span<const std::uint8_t> mapping, std::uint32_t sample_rate, std::uint32_t frame_size, bool continuous) {
    auto mixer = std::make_shared<audio_mixer_t>(mapping, sample_rate, frame_size, continuous);
    hub->attach(mixer);
    return mixer;
  }
  void audio_output_t::detach(const std::shared_ptr<audio_mixer_t> &mixer) {
    hub->detach(mixer);
  }
  namespace {
    /**
     * @brief Sunshine audio capture of the guest's playback.
     */
    class mic_t: public platf::mic_t {
    public:
      /**
       * @brief Capture from an attached mixer.
       *
       * @param output Output the mixer is attached to.
       * @param mixer Attached mixer.
       */
      mic_t(std::shared_ptr<audio_output_t> output, std::shared_ptr<audio_mixer_t> mixer):
          output {std::move(output)},
          mixer {std::move(mixer)} {
      }
      ~mic_t() override {
        output->detach(mixer);
      }
      mic_t(const mic_t &) = delete;
      mic_t &operator=(const mic_t &) = delete;
      /**
       * @brief Read one frame of the guest's audio.
       *
       * @param frame_buffer Destination for interleaved float samples.
       * @return `ok` with a frame, `timeout` when the guest plays nothing (and continuous audio is
       * off), `reinit` when QEMU closed the connection.
       */
      platf::capture_e sample(std::vector<float> &frame_buffer) override {
        switch (mixer->read(frame_buffer, sample_timeout)) {
          case read_status_e::ok:
            return platf::capture_e::ok;
          case read_status_e::timeout:
            return platf::capture_e::timeout;
          case read_status_e::closed:
          default:
            BOOST_LOG(info) << "qemu: guest audio connection closed"sv;
            return platf::capture_e::reinit;
        }
      }
    private:
      std::shared_ptr<audio_output_t> output;  ///< Keeps the listener registered.
      std::shared_ptr<audio_mixer_t> mixer;  ///< Converts and buffers the guest audio.
    };
    /**
     * @brief Audio control for `capture = qemu`: no sinks, microphones read the VM's playback.
     */
    class audio_control_t: public platf::audio_control_t {
    public:
      /**
       * @brief Create a control for a QEMU bus.
       *
       * @param address D-Bus address, or empty for the session bus.
       */
      explicit audio_control_t(std::string address):
          address {std::move(address)} {
      }
      /**
       * @brief Accept any sink; a VM has none to switch.
       *
       * @param sink Requested sink.
       * @return Always 0.
       */
      int set_sink(const std::string &sink) override {
        BOOST_LOG(debug) << "qemu: ignoring audio sink ["sv << sink << "], guest audio comes from QEMU"sv;
        return 0;
      }
      /**
       * @brief Capture the guest's audio output in the requested layout.
       *
       * @param mapping Speaker of each channel.
       * @param channels Number of channels.
       * @param sample_rate Sample rate in hertz.
       * @param frame_size Frames per sample() call.
       * @param continuous Whether silence is sent while the guest plays nothing.
       * @param host_audio_enabled Unused; the guest's audio isn't played on the host.
       * @return Microphone, or nullptr when QEMU or its D-Bus audio is unavailable.
       */
      std::unique_ptr<platf::mic_t> microphone(const std::uint8_t *mapping, int channels, std::uint32_t sample_rate, std::uint32_t frame_size, bool continuous, [[maybe_unused]] bool host_audio_enabled) override {
        std::lock_guard lock {mutex};
        if (!output || !output->alive()) {
          output.reset();
          output = audio_output_t::connect(shared_session(address));
          if (!output) {
            BOOST_LOG(error) << "qemu: no guest audio; QEMU needs -audiodev dbus,id=<id> and -display dbus,audiodev=<id>"sv;
            return nullptr;
          }
        }
        BOOST_LOG(info) << "qemu: streaming guest audio as "sv << channels << " channel(s) at "sv << sample_rate << " Hz"sv << (continuous ? ", continuous"sv : ""sv);
        auto mixer = output->attach({mapping, (std::size_t) channels}, sample_rate, frame_size, continuous);
        return std::make_unique<mic_t>(output, std::move(mixer));
      }
      /**
       * @brief Report the synthetic sink as available.
       *
       * @param sink Sink name.
       * @return Always true.
       */
      bool is_sink_available(const std::string &sink) override {
        return true;
      }
      /**
       * @brief Report a synthetic host sink and no virtual sinks, so Sunshine never switches sinks.
       *
       * @return Sink named "qemu".
       */
      std::optional<platf::sink_t> sink_info() override {
        platf::sink_t sink;
        sink.host = "qemu";
        return sink;
      }
    private:
      std::string address;  ///< D-Bus address of QEMU's bus.
      std::mutex mutex;  ///< Guards `output`.
      std::shared_ptr<audio_output_t> output;  ///< Listener shared by this control's microphones.
    };
  }  // namespace
  std::unique_ptr<platf::audio_control_t> make_audio_control(std::string address) {
    return std::make_unique<audio_control_t>(std::move(address));
  }
}  // namespace qemu
namespace platf {
  /**
   * @brief Create the audio control for `capture = qemu`.
   *
   * @return Audio control reading the guest's audio from `qemu_dbus_address`.
   */
  std::unique_ptr<audio_control_t> qemu_audio_control() {
    return qemu::make_audio_control(config::video.qemu_dbus_address);
  }
}  // namespace platf

@@ -1,0 +1,88 @@
/**
 * @file src/platform/linux/qemu/audio.h
 * @brief Declarations for streaming a QEMU guest's audio output (`capture = qemu`).
 * @details QEMU accepts one `AudioOutListener` per D-Bus client, so one registration per VM
 * session feeds every Sunshine audio capture: `audio_output_t` owns the registration, remembers
 * the state of each guest stream (format, enabled, volume) and fans the calls out to one
 * `audio_mixer_t` per capture.
 */
#pragma once
// standard includes
#include <cstdint>
#include <memory>
#include <mutex>
#include <span>
#include <string>
#include <vector>
// local includes
#include "audio_mixer.h"
#include "session.h"
#include "src/platform/common.h"
namespace qemu {
  class audio_hub_t;
  /**
   * @brief The audio playback listener of one VM session, shared by every Sunshine audio capture.
   */
  class audio_output_t {
  public:
    /**
     * @brief Register a playback listener on a session.
     *
     * @param session Session to the VM.
     * @return Output, or nullptr when QEMU has no D-Bus audio or refused the listener.
     */
    static std::shared_ptr<audio_output_t> connect(std::shared_ptr<session_t> session);
    ~audio_output_t();
    audio_output_t(const audio_output_t &) = delete;
    audio_output_t &operator=(const audio_output_t &) = delete;
    /**
     * @brief Report whether QEMU and the listener connection are still there.
     *
     * @return False once the session died or QEMU closed the listener connection.
     */
    [[nodiscard]] bool alive() const;
    /**
     * @brief Create a mixer that receives the guest audio, starting with the current streams.
     *
     * @param mapping Speaker of each output channel (`platf::speaker::speaker_e`).
     * @param sample_rate Output sample rate in hertz.
     * @param frame_size Output frames per read.
     * @param continuous Whether the mixer produces silence while no audio plays.
     * @return Attached mixer.
     */
    std::shared_ptr<audio_mixer_t> attach(std::span<const std::uint8_t> mapping, std::uint32_t sample_rate, std::uint32_t frame_size, bool continuous);
    /**
     * @brief Stop feeding a mixer.
     *
     * @param mixer Mixer returned by `attach()`.
     */
    void detach(const std::shared_ptr<audio_mixer_t> &mixer);
  private:
    audio_output_t() = default;
    std::shared_ptr<session_t> session;  ///< Session to the VM.
    std::shared_ptr<audio_hub_t> hub;  ///< Receives QEMU's calls and fans them out.
    std::unique_ptr<listener_registration_t> registration;  ///< Keeps the listener registered.
  };
  /**
   * @brief Create the audio control used when `capture = qemu`.
   * @details Sinks don't exist for a VM: `sink_info()` reports a synthetic host sink named "qemu"
   * and `set_sink()` does nothing, so Sunshine's audio pipeline runs unchanged. The QEMU session
   * is opened by the first `microphone()` call and re-opened when the VM went away.
   *
   * @param address D-Bus address of QEMU's bus, or empty for the session bus.
   * @return Audio control; never nullptr.
   */
  std::unique_ptr<platf::audio_control_t> make_audio_control(std::string address);
}  // namespace qemu

@@ -1,0 +1,547 @@
/**
 * @file src/platform/linux/qemu/audio_mixer.cpp
 * @brief Definitions for converting and mixing QEMU guest audio into Sunshine's capture format.
 */
// class header include
#include "audio_mixer.h"
// standard includes
#include <algorithm>
#include <array>
#include <bit>
#include <cmath>
#include <cstring>
#include <numbers>
#include <numeric>
#include <string>
// local includes
#include "src/logging.h"
using namespace std::literals;
namespace qemu {
  namespace {
    constexpr int half_taps = 24;  ///< Filter taps on each side of the interpolated position.
    constexpr int phases = 256;  ///< Tabulated fractional positions between two input samples.
    constexpr double kaiser_beta = 8.0;  ///< Kaiser window shape, about 80 dB stopband attenuation.
    constexpr double passband = 0.97;  ///< Cutoff as a fraction of the lower Nyquist frequency.
    constexpr auto min_underrun_threshold = 80ms;  ///< Shortest time without writes that counts as stopped audio.
    constexpr auto buffer_duration = 200ms;  ///< Audio kept for a slow reader before the oldest is dropped.
    /**
     * @brief Speakers of Sunshine's layouts, as numbered by `platf::speaker::speaker_e`.
     */
    enum speaker_e : std::uint8_t {
      front_left,  ///< Front left.
      front_right,  ///< Front right.
      front_center,  ///< Front center.
      low_frequency,  ///< Low frequency effects.
      back_left,  ///< Back left.
      back_right,  ///< Back right.
      side_left,  ///< Side left.
      side_right,  ///< Side right.
      speaker_count,  ///< Number of speakers.
    };
    /**
     * @brief Speakers of a WAVE/ALSA channel layout with 1 to 8 channels.
     *
     * @param channels Channel count, clamped to 8.
     * @return Speaker of each channel; `speaker_count` for an ignored channel.
     */
    std::vector<std::uint8_t> guest_layout(int channels) {
      switch (channels) {
        case 1:
          return {front_center};
        case 2:
          return {front_left, front_right};
        case 3:
          return {front_left, front_right, front_center};
        case 4:
          return {front_left, front_right, back_left, back_right};
        case 5:
          return {front_left, front_right, front_center, back_left, back_right};
        case 6:
          return {front_left, front_right, front_center, low_frequency, back_left, back_right};
        case 7:
          return {front_left, front_right, front_center, low_frequency, back_left, back_right, speaker_count};
        default:
          {
            std::vector<std::uint8_t> layout {front_left, front_right, front_center, low_frequency, back_left, back_right, side_left, side_right};
            layout.resize(channels, speaker_count);
            return layout;
          }
      }
    }
    /**
     * @brief Zeroth-order modified Bessel function of the first kind, for the Kaiser window.
     *
     * @param x Argument.
     * @return I0(x).
     */
    double bessel_i0(double x) {
      double sum = 1;
      double term = 1;
      for (int k = 1; k < 50; ++k) {
        term *= (x / (2 * k)) * (x / (2 * k));
        sum += term;
        if (term < sum * 1e-12) {
          break;
        }
      }
      return sum;
    }
    /**
     * @brief Read an unsigned integer sample of 1, 2 or 4 bytes.
     *
     * @param p Sample bytes.
     * @param bytes Sample size.
     * @param big_endian Byte order.
     * @return Raw value.
     */
    std::uint32_t read_raw(const std::uint8_t *p, int bytes, bool big_endian) {
      std::uint32_t value = 0;
      for (int i = 0; i < bytes; ++i) {
        const int shift = 8 * (big_endian ? bytes - 1 - i : i);
        value |= (std::uint32_t) p[i] << shift;
      }
      return value;
    }
  }  // namespace
  std::string to_string(const pcm_format_t &format) {
    std::string kind = "unsigned";
    if (format.is_float) {
      kind = "float";
    } else if (format.is_signed) {
      kind = "signed";
    }
    return std::to_string(format.bits) + "-bit " + kind + (format.big_endian ? " big-endian" : "") + ", " + std::to_string(format.freq) + " Hz, " + std::to_string(format.channels) + " channel(s), " + std::to_string(format.bytes_per_frame) + " bytes per frame";
  }
  void pcm_to_float(const pcm_format_t &format, std::span<const std::uint8_t> data, std::vector<float> &out) {
    const int bytes = format.bits / 8;
    const std::size_t samples = data.size() / format.bytes_per_frame * format.channels;
    const std::size_t first = out.size();
    out.resize(first + samples);
    const double scale = 1.0 / (double) (1ULL << (format.bits - 1));
    const std::uint32_t sign_bit = 1U << (format.bits - 1);
    for (std::size_t i = 0; i < samples; ++i) {
      const auto raw = read_raw(data.data() + i * bytes, bytes, format.big_endian);
      float value;
      if (format.is_float) {
        value = std::bit_cast<float>(raw);
      } else if (format.is_signed) {
        // sign-extend, then scale so the most negative value is -1
        const std::int64_t signed_value = (std::int64_t) raw - ((raw & sign_bit) ? (std::int64_t) sign_bit * 2 : 0);
        value = (float) (signed_value * scale);
      } else {
        value = (float) (((std::int64_t) raw - (std::int64_t) sign_bit) * scale);
      }
      out[first + i] = value;
    }
  }
  std::vector<float> channel_matrix(int in_channels, std::span<const std::uint8_t> out_mapping) {
    const auto out_channels = out_mapping.size();
    std::vector<float> matrix(out_channels * in_channels, 0.0f);
    std::array<int, speaker_count> index {};
    index.fill(-1);
    for (std::size_t o = 0; o < out_channels; ++o) {
      if (out_mapping[o] < speaker_count && index[out_mapping[o]] < 0) {
        index[out_mapping[o]] = (int) o;
      }
    }
    const auto has = [&](std::uint8_t speaker) {
      return index[speaker] >= 0;
    };
    const float half = (float) std::numbers::sqrt2 / 2;
    const auto layout = guest_layout(in_channels);
    for (int in = 0; in < in_channels; ++in) {
      const auto add = [&](std::uint8_t speaker, float gain) {
        if (has(speaker)) {
          matrix[index[speaker] * in_channels + in] += gain;
        }
      };
      const auto speaker = layout[in];
      if (speaker == speaker_count) {
        continue;
      }
      if (has(speaker)) {
        add(speaker, 1.0f);
        continue;
      }
      switch (speaker) {
        case front_center:
          add(front_left, half);
          add(front_right, half);
          break;
        case front_left:
        case front_right:
          add(front_center, half);
          break;
        case back_left:
        case back_right:
          {
            const auto side = speaker == back_left ? side_left : side_right;
            if (has(side)) {
              add(side, 1.0f);
            } else {
              add(speaker == back_left ? front_left : front_right, half);
            }
            break;
          }
        case side_left:
        case side_right:
          {
            const auto back = speaker == side_left ? back_left : back_right;
            if (has(back)) {
              add(back, 1.0f);
            } else {
              add(speaker == side_left ? front_left : front_right, half);
            }
            break;
          }
        default:
          // low frequency effects are dropped without a subwoofer
          break;
      }
    }
    return matrix;
  }
  resampler_t::resampler_t(int channels, std::uint32_t in_rate, std::uint32_t out_rate):
      channels {channels} {
    const auto divisor = std::gcd(in_rate, out_rate);
    in_step = in_rate / divisor;
    out_step = out_rate / divisor;
    if (passthrough()) {
      return;
    }
    // windowed sinc, cut off below the lower of the two Nyquist frequencies
    const double cutoff = passband * std::min(1.0, (double) out_rate / in_rate);
    const double window_norm = bessel_i0(kaiser_beta);
    table.resize((phases + 1) * 2 * half_taps);
    for (int phase = 0; phase <= phases; ++phase) {
      double sum = 0;
      const auto row = table.begin() + phase * 2 * half_taps;
      for (int j = 0; j < 2 * half_taps; ++j) {
        const double distance = (j - half_taps + 1) - (double) phase / phases;
        const double x = distance / half_taps;
        const double window = std::abs(x) >= 1 ? 0 : bessel_i0(kaiser_beta * std::sqrt(1 - x * x)) / window_norm;
        const double arg = std::numbers::pi * cutoff * distance;
        const double sinc = distance == 0 ? 1 : std::sin(arg) / arg;
        row[j] = (float) (cutoff * sinc * window);
        sum += row[j];
      }
      for (int j = 0; j < 2 * half_taps; ++j) {
        row[j] = (float) (row[j] / sum);
      }
    }
    reset();
  }
  void resampler_t::process(std::span<const float> in, std::vector<float> &out) {
    if (passthrough()) {
      out.insert(out.end(), in.begin(), in.end());
      return;
    }
    history.insert(history.end(), in.begin(), in.end());
    const std::size_t frames = history.size() / channels;
    while (position + half_taps < frames) {
      const double exact_phase = (double) fraction * phases / out_step;
      const auto phase = (int) exact_phase;
      const auto blend = (float) (exact_phase - phase);
      const float *row0 = table.data() + phase * 2 * half_taps;
      const float *row1 = row0 + 2 * half_taps;
      const float *base = history.data() + (position + 1 - half_taps) * channels;
      for (int c = 0; c < channels; ++c) {
        float sum = 0;
        for (int j = 0; j < 2 * half_taps; ++j) {
          const float tap = row0[j] + blend * (row1[j] - row0[j]);
          sum += tap * base[j * channels + c];
        }
        out.push_back(sum);
      }
      fraction += in_step;
      position += fraction / out_step;
      fraction %= out_step;
    }
    // keep the samples the next output positions still need
    const std::size_t consumed = position - (half_taps - 1);
    if (consumed > 0) {
      history.erase(history.begin(), history.begin() + (std::ptrdiff_t) std::min(consumed, frames) * channels);
      position -= consumed;
    }
  }
  void resampler_t::reset() {
    history.assign((half_taps - 1) * channels, 0.0f);
    position = half_taps - 1;
    fraction = 0;
  }
  audio_mixer_t::audio_mixer_t(std::span<const std::uint8_t> mapping, std::uint32_t sample_rate, std::uint32_t frame_size, bool continuous):
      mapping(mapping.begin(), mapping.end()),
      channels {(int) mapping.size()},
      sample_rate {sample_rate},
      frame_size {frame_size},
      continuous {continuous},
      capacity {std::max<std::size_t>((std::size_t) sample_rate * buffer_duration.count() / 1000, 4 * (std::size_t) frame_size)},
      frame_duration {std::chrono::nanoseconds {1s} * frame_size / sample_rate},
      ring(capacity * channels, 0.0f),
      last_write {std::chrono::steady_clock::now() - 1h} {
  }
  void audio_mixer_t::init(std::uint64_t id, const pcm_format_t &format) {
    std::lock_guard lock {mutex};
    const auto usable = format.valid();
    if (!usable) {
      BOOST_LOG(error) << "qemu: ignoring audio stream "sv << id << " with unsupported PCM: "sv << to_string(format);
    }
    std::uint64_t previous_end = 0;
    if (auto it = streams.find(id); it != streams.end()) {
      previous_end = it->second.write_position;
      streams.erase(it);
    }
    stream_t stream {
      format,
      usable,
      std::vector<float>(usable ? format.channels : 0, 1.0f),
      usable ? channel_matrix(format.channels, mapping) : std::vector<float> {},
      resampler_t {usable ? format.channels : 1, usable ? format.freq : sample_rate, sample_rate},
      {},
      previous_end,
    };
    streams.emplace(id, std::move(stream));
  }
  void audio_mixer_t::fini(std::uint64_t id) {
    std::lock_guard lock {mutex};
    streams.erase(id);
  }
  void audio_mixer_t::set_enabled(std::uint64_t id, bool enabled) {
    std::lock_guard lock {mutex};
    auto it = streams.find(id);
    if (it == streams.end()) {
      return;
    }
    it->second.enabled = enabled;
    it->second.resampler.reset();
    it->second.pending.clear();
  }
  void audio_mixer_t::set_volume(std::uint64_t id, bool mute, std::span<const std::uint8_t> volume) {
    std::lock_guard lock {mutex};
    auto it = streams.find(id);
    if (it == streams.end()) {
      return;
    }
    auto &gains = it->second.gains;
    for (std::size_t c = 0; c < gains.size(); ++c) {
      float gain = 1.0f;
      if (!volume.empty()) {
        gain = volume[std::min(c, volume.size() - 1)] / 255.0f;
      }
      gains[c] = mute ? 0.0f : gain;
    }
  }
  void audio_mixer_t::write(std::uint64_t id, std::span<const std::uint8_t> data) {
    std::lock_guard lock {mutex};
    auto it = streams.find(id);
    if (it == streams.end() || !it->second.usable) {
      return;
    }
    auto &stream = it->second;
    const auto now = std::chrono::steady_clock::now();
    const int in_channels = stream.format.channels;
    // join a frame split across writes
    std::span<const std::uint8_t> bytes = data;
    if (!stream.pending.empty()) {
      stream.pending.insert(stream.pending.end(), data.begin(), data.end());
      bytes = stream.pending;
    }
    scratch_in.clear();
    pcm_to_float(stream.format, bytes, scratch_in);
    const std::size_t used = bytes.size() / stream.format.bytes_per_frame * stream.format.bytes_per_frame;
    std::vector<std::uint8_t> rest(bytes.begin() + (std::ptrdiff_t) used, bytes.end());
    stream.pending = std::move(rest);
    const std::size_t in_frames = scratch_in.size() / in_channels;
    if (in_frames == 0) {
      return;
    }
    longest_block = std::max(longest_block, std::chrono::nanoseconds {std::chrono::nanoseconds {1s} * in_frames / stream.format.freq});
    last_write = now;
    stream.last_write = now;
    for (std::size_t i = 0; i < scratch_in.size(); ++i) {
      scratch_in[i] *= stream.gains[i % in_channels];
    }
    scratch_resampled.clear();
    stream.resampler.process(scratch_in, scratch_resampled);
    const std::uint64_t frames = scratch_resampled.size() / in_channels;
    if (frames == 0) {
      changed.notify_all();
      return;
    }
    // mix at the stream's position, but never into audio that was already read
    std::uint64_t start = std::max(stream.write_position, read_position);
    const std::uint64_t end = start + frames;
    if (end - read_position > capacity) {
      const std::uint64_t new_read = end - capacity;
      const std::uint64_t dropped = std::min(new_read, end_position) - std::min(read_position, end_position);
      counters.dropped_frames += dropped;
      counters.overflows += 1;
      BOOST_LOG(debug) << "qemu: audio buffer full, dropped "sv << dropped * 1000 / sample_rate << " ms of the oldest audio"sv;
      read_position = new_read;
    }
    // fresh space past the previous end holds stale samples; clear it before adding
    for (std::uint64_t pos = std::max(end_position, read_position); pos < end; ++pos) {
      std::fill_n(ring.begin() + (std::ptrdiff_t) ((pos % capacity) * channels), channels, 0.0f);
    }
    const auto &matrix = stream.matrix;
    for (std::uint64_t pos = std::max(start, read_position); pos < end; ++pos) {
      const float *in = scratch_resampled.data() + (pos - start) * in_channels;
      float *out = ring.data() + (pos % capacity) * channels;
      for (int o = 0; o < channels; ++o) {
        float sum = 0;
        for (int c = 0; c < in_channels; ++c) {
          sum += matrix[o * in_channels + c] * in[c];
        }
        out[o] += sum;
      }
    }
    end_position = std::max(end_position, end);
    stream.write_position = end;
    changed.notify_all();
  }
  void audio_mixer_t::close() {
    {
      std::lock_guard lock {mutex};
      closed = true;
    }
    changed.notify_all();
  }
  read_status_e audio_mixer_t::read(std::span<float> frame, std::chrono::milliseconds timeout) {
    std::unique_lock lock {mutex};
    const auto deadline = std::chrono::steady_clock::now() + timeout;
    const std::uint64_t wanted = frame.size() / channels;
    const auto copy_out = [&](std::uint64_t frames) {
      for (std::uint64_t f = 0; f < frames; ++f) {
        const float *in = ring.data() + ((read_position + f) % capacity) * channels;
        for (int c = 0; c < channels; ++c) {
          frame[f * channels + c] = std::clamp(in[c], -1.0f, 1.0f);
        }
      }
      std::fill(frame.begin() + (std::ptrdiff_t) (frames * channels), frame.end(), 0.0f);
      read_position += frames;
    };
    while (true) {
      if (closed) {
        return read_status_e::closed;
      }
      const auto now = std::chrono::steady_clock::now();
      const auto threshold = underrun_threshold_locked();
      const std::uint64_t available = settled_frames_locked(now, threshold);
      if (available >= wanted) {
        copy_out(wanted);
        silent = false;
        return read_status_e::ok;
      }
      if (now - last_write >= threshold) {
        if (available > 0) {
          // the audio stopped mid-frame: finish the frame with silence
          copy_out(available);
          counters.silent_frames += wanted - available;
          end_position = read_position = read_position + (wanted - available);
          silent = true;
          next_silence = now + frame_duration;
          return read_status_e::ok;
        }
        if (continuous) {
          if (!silent) {
            silent = true;
            next_silence = now;
          }
          if (now >= next_silence) {
            copy_out(0);
            counters.silent_frames += wanted;
            end_position = read_position = read_position + wanted;
            next_silence += frame_duration;
            if (next_silence < now - 10 * frame_duration) {
              next_silence = now + frame_duration;
            }
            return read_status_e::ok;
          }
          changed.wait_until(lock, next_silence);
          continue;
        }
        if (now >= deadline) {
          return read_status_e::timeout;
        }
        changed.wait_until(lock, deadline);
        continue;
      }
      // audio is playing: wait for the rest of the frame
      if (!continuous && now >= deadline && available == 0) {
        return read_status_e::timeout;
      }
      auto wake = last_write + threshold;
      if (!continuous && available == 0) {
        wake = std::min(wake, deadline);
      }
      changed.wait_until(lock, wake);
    }
  }
  std::size_t audio_mixer_t::buffered_frames() const {
    std::lock_guard lock {mutex};
    return end_position - read_position;
  }
  std::chrono::nanoseconds audio_mixer_t::underrun_threshold() const {
    std::lock_guard lock {mutex};
    return underrun_threshold_locked();
  }
  std::uint64_t audio_mixer_t::settled_frames_locked(std::chrono::steady_clock::time_point now, std::chrono::nanoseconds threshold) const {
    std::uint64_t limit = end_position;
    for (const auto &[id, stream] : streams) {
      if (stream.usable && stream.enabled && now - stream.last_write < threshold) {
        limit = std::min(limit, std::max(stream.write_position, read_position));
      }
    }
    return limit - read_position;
  }
  std::chrono::nanoseconds audio_mixer_t::underrun_threshold_locked() const {
    return std::max({std::chrono::nanoseconds {min_underrun_threshold}, 4 * frame_duration, 2 * longest_block});
  }
  audio_mixer_t::stats_t audio_mixer_t::stats() const {
    std::lock_guard lock {mutex};
    return counters;
  }
}  // namespace qemu

@@ -1,0 +1,297 @@
/**
 * @file src/platform/linux/qemu/audio_mixer.h
 * @brief Declarations for converting and mixing QEMU guest audio into Sunshine's capture format.
 * @details QEMU's D-Bus audio backend sends integer or float PCM at the guest device's rate and
 * channel count, one stream per emulated voice. The mixer converts each stream to float, applies
 * the stream volume, resamples it to the rate Sunshine encodes, remaps its channels to the layout
 * Sunshine requested, and adds it into one bounded ring buffer that the audio capture thread
 * drains a frame at a time. It depends only on the standard library so it can be tested without
 * D-Bus.
 */
#pragma once
// standard includes
#include <chrono>
#include <condition_variable>
#include <cstdint>
#include <map>
#include <mutex>
#include <span>
#include <string>
#include <vector>
// local includes
#include "session.h"
namespace qemu {
  /**
   * @brief Describe a PCM layout for logs.
   *
   * @param format Layout to describe.
   * @return Text such as "16-bit signed, 44100 Hz, 2 channel(s), 4 bytes per frame".
   */
  std::string to_string(const pcm_format_t &format);
  /**
   * @brief Convert interleaved PCM to float samples in [-1, 1).
   * @details Only whole frames are converted; a trailing partial frame is ignored.
   *
   * @param format Layout of `data`; must be valid.
   * @param data Interleaved PCM bytes.
   * @param out Receives the converted samples, appended in the same interleaved order.
   */
  void pcm_to_float(const pcm_format_t &format, std::span<const std::uint8_t> data, std::vector<float> &out);
  /**
   * @brief Build the matrix that remaps a guest channel layout to Sunshine's speaker layout.
   * @details A stream with `in_channels` channels is assumed to use the WAVE/ALSA order: mono is
   * front center; 2 is FL FR; 3 is FL FR FC; 4 is FL FR BL BR; 5 is FL FR FC BL BR; 6 is 5.1
   * (FL FR FC LFE BL BR); 7 is 5.1 plus an ignored channel; 8 or more is 7.1 (FL FR FC LFE BL BR
   * SL SR) and further channels are ignored. Speakers the output has are copied. A missing
   * center or front pair is folded into the other at -3 dB, missing side speakers go to the back
   * (and vice versa) or to the front pair at -3 dB, and LFE is dropped when the output has none,
   * like FFmpeg's default rematrixing.
   *
   * @param in_channels Channels of the guest stream.
   * @param out_mapping Speaker (`platf::speaker::speaker_e`) of each output channel.
   * @return Gains, `out_mapping.size()` rows of `in_channels` columns, row-major.
   */
  std::vector<float> channel_matrix(int in_channels, std::span<const std::uint8_t> out_mapping);
  /**
   * @brief Streaming band-limited sample rate converter.
   * @details A polyphase windowed-sinc interpolator (48 taps, Kaiser window, 256 interpolated
   * phases) with exact rational stepping, so it never drifts. The cutoff is 97% of the lower of
   * the two Nyquist frequencies. It delays the signal by 24 input samples. FFmpeg's swresample
   * isn't used because the FFmpeg build Sunshine links doesn't include it.
   */
  class resampler_t {
  public:
    /**
     * @brief Create a converter.
     *
     * @param channels Interleaved channels.
     * @param in_rate Input sample rate in hertz.
     * @param out_rate Output sample rate in hertz.
     */
    resampler_t(int channels, std::uint32_t in_rate, std::uint32_t out_rate);
    /**
     * @brief Convert a block of samples; state carries over to the next block.
     *
     * @param in Interleaved input samples (whole frames).
     * @param out Receives the output samples, appended.
     */
    void process(std::span<const float> in, std::vector<float> &out);
    /**
     * @brief Forget buffered input, as after a gap in the stream.
     */
    void reset();
    /**
     * @brief Report whether the rates are equal and samples pass through unchanged.
     *
     * @return True when no conversion happens.
     */
    [[nodiscard]] bool passthrough() const {
      return in_step == out_step;
    }
  private:
    int channels;  ///< Interleaved channels.
    std::uint32_t in_step;  ///< Input rate divided by the rates' greatest common divisor.
    std::uint32_t out_step;  ///< Output rate divided by the rates' greatest common divisor.
    std::vector<float> table;  ///< Filter taps, (phases + 1) rows of 2 * half_taps.
    std::vector<float> history;  ///< Buffered interleaved input.
    std::size_t position {0};  ///< Input frame of the next output sample.
    std::uint64_t fraction {0};  ///< Fractional position of the next output sample, in 1 / out_step.
  };
  /**
   * @brief Result of reading a frame from the mixer.
   */
  enum class read_status_e {
    ok,  ///< The frame holds audio or silence.
    timeout,  ///< No audio arrived in time; nothing was written.
    closed,  ///< The connection to QEMU closed.
  };
  /**
   * @brief Converts QEMU playback streams and mixes them into frames for one Sunshine audio capture.
   * @details Writers (the D-Bus listener thread) never block on the reader. The ring buffer holds
   * at most `capacity_frames()`; when the reader falls behind, the oldest audio is dropped. With
   * several playing streams, only audio that all of them have written is read, so a frame never
   * goes out with one stream's block still missing.
   *
   * Underruns: audio is considered to have stopped when no stream wrote for
   * `underrun_threshold()` (at least 80 ms, and twice the longest block QEMU sends, so QEMU's
   * normal 10 ms pacing and scheduling jitter aren't mistaken for silence). Until then `read()`
   * waits for a full frame. After that a partial frame is completed with silence; then, when
   * `continuous` is set, silent frames follow at the real-time frame rate (like a PulseAudio
   * monitor of an idle sink), otherwise `read()` returns `timeout` so no packets are sent.
   */
  class audio_mixer_t {
  public:
    /**
     * @brief Counters for tests and logs.
     */
    struct stats_t {
      std::uint64_t dropped_frames {0};  ///< Output frames discarded because the buffer was full.
      std::uint64_t overflows {0};  ///< Writes that discarded audio.
      std::uint64_t silent_frames {0};  ///< Output frames of silence inserted on underrun.
    };
    /**
     * @brief Create a mixer for one capture layout.
     *
     * @param mapping Speaker of each output channel (`platf::speaker::speaker_e`).
     * @param sample_rate Output sample rate in hertz.
     * @param frame_size Output frames per `read()`.
     * @param continuous Whether silence is produced while no audio plays.
     */
    audio_mixer_t(std::span<const std::uint8_t> mapping, std::uint32_t sample_rate, std::uint32_t frame_size, bool continuous);
    /**
     * @brief Start or restart a stream.
     *
     * @param id Stream id.
     * @param format PCM layout of the stream; invalid layouts make the stream ignored.
     */
    void init(std::uint64_t id, const pcm_format_t &format);
    /**
     * @brief Remove a stream and whatever of it is not yet mixed.
     *
     * @param id Stream id.
     */
    void fini(std::uint64_t id);
    /**
     * @brief Resume or suspend a stream; either way its converter starts over.
     *
     * @param id Stream id.
     * @param enabled Whether the stream plays.
     */
    void set_enabled(std::uint64_t id, bool enabled);
    /**
     * @brief Set the volume of a stream.
     *
     * @param id Stream id.
     * @param mute Whether the stream is muted.
     * @param volume Linear gain per input channel, 0 to 255 (255 is unity). Channels without an
     * entry use the last entry; an empty list means unity.
     */
    void set_volume(std::uint64_t id, bool mute, std::span<const std::uint8_t> volume);
    /**
     * @brief Convert and mix PCM data of a stream.
     *
     * @param id Stream id.
     * @param data Interleaved PCM in the stream's format.
     */
    void write(std::uint64_t id, std::span<const std::uint8_t> data);
    /**
     * @brief Mark the source as gone; pending and future reads return `closed`.
     */
    void close();
    /**
     * @brief Read one frame of interleaved float samples.
     *
     * @param frame Destination of `frame_size * channels` samples; its size sets the frames read.
     * @param timeout Longest wait for audio when not `continuous`.
     * @return `ok` when `frame` was filled, `timeout` when no audio arrived, `closed` when QEMU went away.
     */
    read_status_e read(std::span<float> frame, std::chrono::milliseconds timeout);
    /**
     * @brief Count the output frames waiting to be read.
     *
     * @return Buffered frames.
     */
    [[nodiscard]] std::size_t buffered_frames() const;
    /**
     * @brief Get the buffer bound.
     *
     * @return Maximum buffered frames.
     */
    [[nodiscard]] std::size_t capacity_frames() const {
      return capacity;
    }
    /**
     * @brief Get the time without writes after which audio counts as stopped.
     *
     * @return Current underrun threshold.
     */
    [[nodiscard]] std::chrono::nanoseconds underrun_threshold() const;
    /**
     * @brief Snapshot the counters.
     *
     * @return Counters.
     */
    [[nodiscard]] stats_t stats() const;
  private:
    /**
     * @brief Compute the underrun threshold; the caller holds the mutex.
     *
     * @return Time without writes after which audio counts as stopped.
     */
    [[nodiscard]] std::chrono::nanoseconds underrun_threshold_locked() const;
    /**
     * @brief Count the frames every playing stream has written; the caller holds the mutex.
     * @details Frames past the position of a stream that is still playing (enabled and wrote
     * within the underrun threshold) aren't complete yet: that stream's next block belongs there.
     *
     * @param now Current time.
     * @param threshold Underrun threshold.
     * @return Frames that can be read without cutting into a playing stream.
     */
    [[nodiscard]] std::uint64_t settled_frames_locked(std::chrono::steady_clock::time_point now, std::chrono::nanoseconds threshold) const;
    /**
     * @brief Per-stream conversion state.
     */
    struct stream_t {
      pcm_format_t format;  ///< PCM layout.
      bool usable {false};  ///< Whether the layout is valid.
      std::vector<float> gains;  ///< Gain per input channel.
      std::vector<float> matrix;  ///< Output-by-input remix gains.
      resampler_t resampler;  ///< Rate converter.
      std::vector<std::uint8_t> pending;  ///< Bytes of an incomplete frame from the previous write.
      std::uint64_t write_position {0};  ///< Absolute output frame after the stream's last block; a block is mixed at the later of this and the read position.
      std::chrono::steady_clock::time_point last_write {};  ///< When the stream last wrote.
      bool enabled {true};  ///< Whether QEMU reports the stream as playing.
    };
    std::vector<std::uint8_t> mapping;  ///< Speaker of each output channel.
    int channels;  ///< Output channels.
    std::uint32_t sample_rate;  ///< Output sample rate.
    std::uint32_t frame_size;  ///< Output frames per read.
    bool continuous;  ///< Whether silence is produced on underrun.
    std::size_t capacity;  ///< Maximum buffered frames.
    std::chrono::nanoseconds frame_duration;  ///< Duration of one read.
    mutable std::mutex mutex;  ///< Guards everything below.
    std::condition_variable changed;  ///< Signaled on writes and close.
    std::map<std::uint64_t, stream_t> streams;  ///< Streams by id.
    std::vector<float> ring;  ///< `capacity * channels` samples.
    std::uint64_t read_position {0};  ///< Absolute output frame of the next read.
    std::uint64_t end_position {0};  ///< Absolute output frame after the last mixed one.
    std::chrono::steady_clock::time_point last_write;  ///< When audio was last written.
    std::chrono::nanoseconds longest_block {0};  ///< Longest write seen, in playback time.
    std::chrono::steady_clock::time_point next_silence;  ///< When the next silent frame is due.
    bool silent {false};  ///< Whether silence is being produced.
    bool closed {false};  ///< Whether the source is gone.
    stats_t counters;  ///< Counters.
    std::vector<float> scratch_in;  ///< Converted input of the current write.
    std::vector<float> scratch_resampled;  ///< Resampled input of the current write.
  };
}  // namespace qemu

@@ -41,6 +41,9 @@
    constexpr auto listener_path = "/org/qemu/Display1/Listener";  ///< Object path QEMU calls on the listener connection.
    constexpr auto unix_map_interface = "org.qemu.Display1.Listener.Unix.Map";  ///< Shared memory listener interface.
    constexpr auto scanout_dmabuf2_interface = "org.qemu.Display1.Listener.Unix.ScanoutDMABUF2";  ///< Multi-plane DMABUF listener interface.
    constexpr auto audio_path = "/org/qemu/Display1/Audio";  ///< Object path of the Audio interface.
    constexpr auto audio_out_listener_path = "/org/qemu/Display1/AudioOutListener";  ///< Object path QEMU calls on the audio listener connection.
    constexpr auto registration_retry = 20ms;  ///< Delay between attempts while QEMU still holds a closed audio listener.
    /**
     * @brief Convert a NULL-terminated string vector to a vector of strings.
@@ -205,6 +208,66 @@
      }
    }
    /**
     * @brief Create a socket pair and attach one end to a descriptor list for a Register*Listener call.
     *
     * @param ours Receives our end of the pair.
     * @param index Receives the handle of QEMU's end in the returned list.
     * @return Descriptor list holding QEMU's end, or nullptr on failure.
     */
    GUnixFDList *listener_socket_pair(fd_t &ours, gint &index) {
      int fds[2];
      if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, fds) != 0) {
        BOOST_LOG(error) << "qemu: socketpair failed: "sv << std::strerror(errno);
        return nullptr;
      }
      ours = fd_t {fds[0]};
      fd_t theirs {fds[1]};
      GError *err = nullptr;
      auto fd_list = g_unix_fd_list_new();
      index = g_unix_fd_list_append(fd_list, theirs.get(), &err);
      if (index < 0) {
        BOOST_LOG(error) << "qemu: couldn't attach listener socket: "sv << err->message;
        g_clear_error(&err);
        g_object_unref(fd_list);
        return nullptr;
      }
      return fd_list;
    }
    /**
     * @brief Complete the peer-to-peer D-Bus handshake on our end of a listener socket.
     * @details QEMU is the authentication server on this socket. Message processing is delayed so
     * QEMU's first calls queue until the listener objects are exported.
     *
     * @param socket_fd Our end of the socket pair.
     * @param cancellable Cancels the handshake when the deadline passes.
     * @return Connection with delayed message processing, or nullptr on failure.
     */
    GDBusConnection *open_peer_connection(fd_t socket_fd, GCancellable *cancellable) {
      GError *err = nullptr;
      auto socket = g_socket_new_from_fd(socket_fd.get(), &err);
      if (!socket) {
        BOOST_LOG(error) << "qemu: couldn't wrap listener socket: "sv << err->message;
        g_clear_error(&err);
        return nullptr;
      }
      socket_fd.release();
      auto socket_connection = g_socket_connection_factory_create_connection(socket);
      g_object_unref(socket);
      auto connection = g_dbus_connection_new_sync(G_IO_STREAM(socket_connection), nullptr, (GDBusConnectionFlags) (G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING), nullptr, cancellable, &err);
      g_object_unref(socket_connection);
      if (!connection) {
        BOOST_LOG(error) << "qemu: listener handshake failed: "sv << err->message;
        g_clear_error(&err);
        return nullptr;
      }
      g_dbus_connection_set_exit_on_close(connection, FALSE);
      return connection;
    }
    class session_impl_t;
    /**
@@ -261,6 +324,52 @@
    };
    /**
     * @brief Peer-to-peer audio playback listener registered with `Audio.RegisterOutListener`.
     */
    class audio_listener_impl_t: public listener_registration_t {
    public:
      /**
       * @brief Create an unconnected registration.
       *
       * @param session Session that owns the loop thread.
       * @param listener Receiver for audio calls.
       */
      audio_listener_impl_t(std::shared_ptr<session_impl_t> session, std::shared_ptr<audio_out_listener_t> listener);
      ~audio_listener_impl_t() override;
      /**
       * @brief Complete the peer-to-peer handshake and export the listener object.
       * @details Must run on the listener thread, right after `RegisterOutListener` returned.
       *
       * @param socket_fd Our end of the socket pair.
       * @param cancellable Cancels the handshake when the deadline passes.
       * @return True when the listener is exported.
       */
      bool start(fd_t socket_fd, GCancellable *cancellable);
    private:
      /**
       * @brief Unexport the listener object and close the connection.
       * @details Must run on the listener thread.
       */
      void stop();
      static gboolean on_init(QemuDBusDisplay1AudioOutListener *object, GDBusMethodInvocation *invocation, guint64 id, guchar bits, gboolean is_signed, gboolean is_float, guint freq, guchar nchannels, guint bytes_per_frame, guint bytes_per_second, gboolean be, gpointer self);
      static gboolean on_fini(QemuDBusDisplay1AudioOutListener *object, GDBusMethodInvocation *invocation, guint64 id, gpointer self);
      static gboolean on_set_enabled(QemuDBusDisplay1AudioOutListener *object, GDBusMethodInvocation *invocation, guint64 id, gboolean enabled, gpointer self);
      static gboolean on_set_volume(QemuDBusDisplay1AudioOutListener *object, GDBusMethodInvocation *invocation, guint64 id, gboolean mute, GVariant *volume, gpointer self);
      static gboolean on_write(QemuDBusDisplay1AudioOutListener *object, GDBusMethodInvocation *invocation, guint64 id, GVariant *data, gpointer self);
      static void on_closed(GDBusConnection *connection, gboolean remote_peer_vanished, GError *err, gpointer self);
      std::shared_ptr<session_impl_t> session;  ///< Keeps the loop thread alive while registered.
      std::shared_ptr<audio_out_listener_t> listener;  ///< Receiver for audio calls.
      GDBusConnection *connection {nullptr};  ///< Peer-to-peer connection to QEMU.
      QemuDBusDisplay1AudioOutListener *skeleton {nullptr};  ///< Exported AudioOutListener interface.
      bool closed {false};  ///< Whether the peer closed the connection.
    };
    /**
     * @brief GDBus implementation of the session.
     */
    class session_impl_t: public session_t, public std::enable_shared_from_this<session_impl_t> {
@@ -357,6 +466,19 @@
        return registration;
      }
      std::unique_ptr<listener_registration_t> register_audio_out_listener(std::shared_ptr<audio_out_listener_t> listener) override {
        auto registration = std::make_unique<audio_listener_impl_t>(shared_from_this(), std::move(listener));
        bool ok = false;
        deadline_t deadline {timeout};
        loop.invoke([&]() {
          ok = register_audio_on_loop(*registration, deadline.cancellable);
        });
        if (!ok) {
          return nullptr;
        }
        return registration;
      }
      /**
       * @brief Thread that owns the bus connection and makes blocking calls to QEMU.
       */
@@ -457,6 +579,7 @@
        }
        console_proxies.clear();
        g_clear_object(&vm_proxy);
        g_clear_object(&audio_proxy);
        if (connection) {
          g_signal_handler_disconnect(connection, closed_handler);
          g_dbus_connection_close_sync(connection, nullptr, nullptr);
@@ -481,25 +604,14 @@
          return false;
        }
        int fds[2];
        if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, fds) != 0) {
          BOOST_LOG(error) << "qemu: socketpair failed: "sv << std::strerror(errno);
        fd_t ours;
        gint index = -1;
        auto fd_list = listener_socket_pair(ours, index);
        if (!fd_list) {
          return false;
        }
        fd_t ours {fds[0]};
        fd_t theirs {fds[1]};
        GError *err = nullptr;
        auto fd_list = g_unix_fd_list_new();
        auto index = g_unix_fd_list_append(fd_list, theirs.get(), &err);
        theirs = fd_t {};
        if (index < 0) {
          BOOST_LOG(error) << "qemu: couldn't attach listener socket: "sv << err->message;
          g_clear_error(&err);
          g_object_unref(fd_list);
          return false;
        }
        bool ok = qemu_dbus_display1_console_call_register_listener_sync(it->second, g_variant_new_handle(index), G_DBUS_CALL_FLAGS_NONE, timeout_ms, fd_list, nullptr, cancellable, &err);
        g_object_unref(fd_list);
        if (!ok) {
@@ -515,6 +627,66 @@
        return started;
      }
      /**
       * @brief Hand one end of a socket pair to `Audio.RegisterOutListener`; runs on the loop thread.
       * @details QEMU refuses a second playback listener from the same bus connection until it has
       * processed the close of the previous one, so that refusal is retried until the deadline.
       *
       * @param registration Registration to start on success.
       * @param cancellable Cancels blocking calls when the deadline passes.
       * @return True when the listener is registered.
       */
      bool register_audio_on_loop(audio_listener_impl_t &registration, GCancellable *cancellable) {
        if (!is_alive) {
          BOOST_LOG(error) << "qemu: can't register an audio listener, QEMU is gone"sv;
          return false;
        }
        GError *err = nullptr;
        if (!audio_proxy) {
          audio_proxy = qemu_dbus_display1_audio_proxy_new_sync(connection, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, bus_name, audio_path, cancellable, &err);
          if (!audio_proxy) {
            BOOST_LOG(error) << "qemu: couldn't create Audio proxy: "sv << err->message;
            g_clear_error(&err);
            return false;
          }
          g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(audio_proxy), timeout_ms);
        }
        while (true) {
          fd_t ours;
          gint index = -1;
          auto fd_list = listener_socket_pair(ours, index);
          if (!fd_list) {
            return false;
          }
          bool ok = qemu_dbus_display1_audio_call_register_out_listener_sync(audio_proxy, g_variant_new_handle(index), G_DBUS_CALL_FLAGS_NONE, timeout_ms, fd_list, nullptr, cancellable, &err);
          g_object_unref(fd_list);
          if (ok) {
            bool started = false;
            listener_loop.invoke([&]() {
              started = registration.start(std::move(ours), cancellable);
            });
            return started;
          }
          const bool still_registered = std::string_view {err->message}.find("already registered") != std::string_view::npos;
          if (still_registered && !g_cancellable_is_cancelled(cancellable)) {
            g_clear_error(&err);
            std::this_thread::sleep_for(registration_retry);
            continue;
          }
          if (g_error_matches(err, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_OBJECT) || g_error_matches(err, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD) || g_error_matches(err, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_INTERFACE)) {
            BOOST_LOG(error) << "qemu: QEMU has no D-Bus audio; start it with -audiodev dbus,id=snd0 and -display dbus,audiodev=snd0 ("sv << err->message << ')';
          } else {
            BOOST_LOG(error) << "qemu: RegisterOutListener failed: "sv << err->message;
          }
          g_clear_error(&err);
          return false;
        }
      }
      static void on_bus_closed(GDBusConnection *connection, gboolean remote_peer_vanished, GError *err, gpointer self) {
        BOOST_LOG(warning) << "qemu: D-Bus connection closed"sv;
        ((session_impl_t *) self)->is_alive = false;
@@ -532,5 +704,6 @@
      gulong closed_handler {0};  ///< Handler id of the connection's "closed" signal.
      guint name_watch {0};  ///< Watch on `org.qemu`.
      QemuDBusDisplay1VM *vm_proxy {nullptr};  ///< VM proxy.
      QemuDBusDisplay1Audio *audio_proxy {nullptr};  ///< Audio proxy, created on the first audio registration.
      std::vector<std::pair<std::uint32_t, QemuDBusDisplay1Console *>> console_proxies;  ///< Console proxies in ConsoleIDs order.
    };
@@ -547,28 +720,12 @@
    }
    bool listener_impl_t::start(fd_t socket_fd, GCancellable *cancellable) {
      GError *err = nullptr;
      auto socket = g_socket_new_from_fd(socket_fd.get(), &err);
      if (!socket) {
        BOOST_LOG(error) << "qemu: couldn't wrap listener socket: "sv << err->message;
        g_clear_error(&err);
        return false;
      }
      socket_fd.release();
      auto socket_connection = g_socket_connection_factory_create_connection(socket);
      g_object_unref(socket);
      connection = open_peer_connection(std::move(socket_fd), cancellable);
      // QEMU is the authentication server on this socket. Delay message processing so QEMU's first
      // calls (property fetch, ScanoutMap) queue until the listener objects are exported.
      connection = g_dbus_connection_new_sync(G_IO_STREAM(socket_connection), nullptr, (GDBusConnectionFlags) (G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING), nullptr, cancellable, &err);
      g_object_unref(socket_connection);
      if (!connection) {
        BOOST_LOG(error) << "qemu: listener handshake failed: "sv << err->message;
        g_clear_error(&err);
        return false;
      }
      g_dbus_connection_set_exit_on_close(connection, FALSE);
      GError *err = nullptr;
      skeleton = qemu_dbus_display1_listener_skeleton_new();
      const gchar *interfaces[] = {unix_map_interface, scanout_dmabuf2_interface, nullptr};
      qemu_dbus_display1_listener_set_interfaces(skeleton, interfaces);
@@ -752,6 +909,109 @@
    void listener_impl_t::on_closed(GDBusConnection *connection, gboolean remote_peer_vanished, GError *err, gpointer self) {
      auto registration = (listener_impl_t *) self;
      BOOST_LOG(info) << "qemu: display listener connection closed"sv;
      registration->closed = true;
      registration->listener->disconnected();
    }
    audio_listener_impl_t::audio_listener_impl_t(std::shared_ptr<session_impl_t> session, std::shared_ptr<audio_out_listener_t> listener):
        session {std::move(session)},
        listener {std::move(listener)} {
    }
    audio_listener_impl_t::~audio_listener_impl_t() {
      session->listener_loop.invoke([this]() {
        stop();
      });
    }
    bool audio_listener_impl_t::start(fd_t socket_fd, GCancellable *cancellable) {
      connection = open_peer_connection(std::move(socket_fd), cancellable);
      if (!connection) {
        return false;
      }
      skeleton = qemu_dbus_display1_audio_out_listener_skeleton_new();
      const gchar *interfaces[] = {nullptr};
      qemu_dbus_display1_audio_out_listener_set_interfaces(skeleton, interfaces);
      g_signal_connect(skeleton, "handle-init", G_CALLBACK(&audio_listener_impl_t::on_init), this);
      g_signal_connect(skeleton, "handle-fini", G_CALLBACK(&audio_listener_impl_t::on_fini), this);
      g_signal_connect(skeleton, "handle-set-enabled", G_CALLBACK(&audio_listener_impl_t::on_set_enabled), this);
      g_signal_connect(skeleton, "handle-set-volume", G_CALLBACK(&audio_listener_impl_t::on_set_volume), this);
      g_signal_connect(skeleton, "handle-write", G_CALLBACK(&audio_listener_impl_t::on_write), this);
      GError *err = nullptr;
      if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(skeleton), connection, audio_out_listener_path, &err)) {
        BOOST_LOG(error) << "qemu: couldn't export audio listener: "sv << err->message;
        g_clear_error(&err);
        stop();
        return false;
      }
      g_signal_connect(connection, "closed", G_CALLBACK(&audio_listener_impl_t::on_closed), this);
      g_dbus_connection_start_message_processing(connection);
      return true;
    }
    void audio_listener_impl_t::stop() {
      if (skeleton) {
        g_signal_handlers_disconnect_by_data(skeleton, this);
        g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(skeleton));
        g_clear_object(&skeleton);
      }
      if (connection) {
        g_signal_handlers_disconnect_by_data(connection, this);
        if (!closed) {
          g_dbus_connection_close_sync(connection, nullptr, nullptr);
        }
        g_clear_object(&connection);
      }
    }
    gboolean audio_listener_impl_t::on_init(QemuDBusDisplay1AudioOutListener *object, GDBusMethodInvocation *invocation, guint64 id, guchar bits, gboolean is_signed, gboolean is_float, guint freq, guchar nchannels, guint bytes_per_frame, guint bytes_per_second, gboolean be, gpointer self) {
      pcm_format_t format;
      format.bits = bits;
      format.is_signed = is_signed;
      format.is_float = is_float;
      format.freq = freq;
      format.channels = nchannels;
      format.bytes_per_frame = bytes_per_frame;
      format.big_endian = be;
      ((audio_listener_impl_t *) self)->listener->init(id, format);
      qemu_dbus_display1_audio_out_listener_complete_init(object, invocation);
      return TRUE;
    }
    gboolean audio_listener_impl_t::on_fini(QemuDBusDisplay1AudioOutListener *object, GDBusMethodInvocation *invocation, guint64 id, gpointer self) {
      ((audio_listener_impl_t *) self)->listener->fini(id);
      qemu_dbus_display1_audio_out_listener_complete_fini(object, invocation);
      return TRUE;
    }
    gboolean audio_listener_impl_t::on_set_enabled(QemuDBusDisplay1AudioOutListener *object, GDBusMethodInvocation *invocation, guint64 id, gboolean enabled, gpointer self) {
      ((audio_listener_impl_t *) self)->listener->set_enabled(id, enabled);
      qemu_dbus_display1_audio_out_listener_complete_set_enabled(object, invocation);
      return TRUE;
    }
    gboolean audio_listener_impl_t::on_set_volume(QemuDBusDisplay1AudioOutListener *object, GDBusMethodInvocation *invocation, guint64 id, gboolean mute, GVariant *volume, gpointer self) {
      gsize size = 0;
      auto bytes = (const std::uint8_t *) g_variant_get_fixed_array(volume, &size, 1);
      ((audio_listener_impl_t *) self)->listener->set_volume(id, mute, {bytes, size});
      qemu_dbus_display1_audio_out_listener_complete_set_volume(object, invocation);
      return TRUE;
    }
    gboolean audio_listener_impl_t::on_write(QemuDBusDisplay1AudioOutListener *object, GDBusMethodInvocation *invocation, guint64 id, GVariant *data, gpointer self) {
      gsize size = 0;
      auto bytes = (const std::uint8_t *) g_variant_get_fixed_array(data, &size, 1);
      ((audio_listener_impl_t *) self)->listener->write(id, {bytes, size});
      qemu_dbus_display1_audio_out_listener_complete_write(object, invocation);
      return TRUE;
    }
    void audio_listener_impl_t::on_closed(GDBusConnection *connection, gboolean remote_peer_vanished, GError *err, gpointer self) {
      auto registration = (audio_listener_impl_t *) self;
      BOOST_LOG(info) << "qemu: audio listener connection closed"sv;
      registration->closed = true;
      registration->listener->disconnected();
    }

@@ -243,7 +243,88 @@
  };
  /**
   * @brief PCM layout of a playback stream, as announced by `AudioOutListener.Init`.
   */
  struct pcm_format_t {
    std::uint8_t bits {16};  ///< Bits per sample: 8, 16 or 32.
    bool is_signed {true};  ///< Whether integer samples are signed.
    bool is_float {false};  ///< Whether samples are IEEE floats (32 bits only).
    std::uint32_t freq {44100};  ///< Sample rate in hertz.
    std::uint8_t channels {2};  ///< Interleaved channels per frame.
    std::uint32_t bytes_per_frame {4};  ///< Bytes per interleaved frame.
    bool big_endian {false};  ///< Whether samples are big-endian.
    /**
     * @brief Report whether Sunshine can convert this layout.
     *
     * @return True for 8, 16 or 32 bit integers, 32 bit floats, 1 to 255 channels, a consistent
     * frame size and a sample rate between 1 kHz and 768 kHz.
     */
    [[nodiscard]] bool valid() const {
      const bool bits_ok = is_float ? bits == 32 : (bits == 8 || bits == 16 || bits == 32);
      return bits_ok && channels > 0 && bytes_per_frame == (std::uint32_t) (bits / 8) * channels && freq >= 1000 && freq <= 768000;
    }
  };
  /**
   * @brief Receiver for the `org.qemu.Display1.AudioOutListener` calls QEMU makes.
   * @details All methods are invoked on the session's listener thread and must return quickly.
   * QEMU identifies each playback stream (an emulated audio voice) by an id; several streams can
   * be active at once.
   */
  class audio_out_listener_t {
  public:
    virtual ~audio_out_listener_t() = default;
    /**
     * @brief Handle a playback stream being created or re-created.
     *
     * @param id Stream id.
     * @param format PCM layout of the stream's `Write` data.
     */
    virtual void init(std::uint64_t id, const pcm_format_t &format) = 0;
    /**
     * @brief Handle a playback stream being closed.
     *
     * @param id Stream id.
     */
    virtual void fini(std::uint64_t id) = 0;
    /**
     * @brief Handle a playback stream being resumed or suspended.
     *
     * @param id Stream id.
     * @param enabled Whether the stream plays.
     */
    virtual void set_enabled(std::uint64_t id, bool enabled) = 0;
    /**
     * @brief Handle a volume or mute change of a playback stream.
     *
     * @param id Stream id.
     * @param mute Whether the stream is muted.
     * @param volume Linear volume of each channel, 0 to 255; valid only for the duration of the call.
     */
    virtual void set_volume(std::uint64_t id, bool mute, std::span<const std::uint8_t> volume) = 0;
    /**
     * @brief Handle PCM data of a playback stream.
     *
     * @param id Stream id.
     * @param data Interleaved PCM in the stream's format; valid only for the duration of the call.
     */
    virtual void write(std::uint64_t id, std::span<const std::uint8_t> data) = 0;
   * @brief Registration of a display listener; destroying it unregisters the listener.
    /**
     * @brief Handle the peer-to-peer connection to QEMU closing.
     * @details Called at most once. No other method is called afterwards.
     */
    virtual void disconnected() = 0;
  };
  /**
   * @brief Registration of a display or audio listener; destroying it unregisters the listener.
   * @details After the destructor returns, no method of the listener is invoked again.
   */
  class listener_registration_t {
@@ -297,6 +378,18 @@
     * @return Registration handle, or nullptr when QEMU refused the listener.
     */
    virtual std::unique_ptr<listener_registration_t> register_listener(std::uint32_t console_id, std::shared_ptr<display_listener_t> listener) = 0;
    /**
     * @brief Register an audio playback listener with `org.qemu.Display1.Audio.RegisterOutListener`.
     * @details QEMU exports the Audio object only when it runs with `-audiodev dbus,id=<id>` and
     * `-display dbus,audiodev=<id>`. QEMU accepts one playback listener per bus connection, so
     * callers should share one registration; a registration made right after the previous one was
     * destroyed is retried until QEMU has noticed the old connection closing.
     *
     * @param listener Receiver for the audio calls; kept alive by the registration.
     * @return Registration handle, or nullptr when QEMU has no D-Bus audio or refused the listener.
     */
    virtual std::unique_ptr<listener_registration_t> register_audio_out_listener(std::shared_ptr<audio_out_listener_t> listener) = 0;
  };
  /**

@@ -1,0 +1,169 @@
/**
 * @file tests/unit/platform/linux/qemu/audio_analysis.h
 * @brief Signal generation and analysis helpers for the QEMU audio tests.
 */
#pragma once
// standard includes
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdint>
#include <numbers>
#include <span>
#include <vector>
namespace qemu_test {
  /**
   * @brief Take one channel out of interleaved samples.
   *
   * @param samples Interleaved samples.
   * @param channels Channels per frame.
   * @param channel Channel to extract.
   * @return Samples of that channel.
   */
  inline std::vector<float> channel_of(std::span<const float> samples, int channels, int channel) {
    std::vector<float> out;
    out.reserve(samples.size() / channels);
    for (std::size_t i = channel; i < samples.size(); i += channels) {
      out.push_back(samples[i]);
    }
    return out;
  }
  /**
   * @brief Root mean square of samples.
   *
   * @param samples Samples.
   * @return RMS, or 0 for no samples.
   */
  inline double rms(std::span<const float> samples) {
    if (samples.empty()) {
      return 0;
    }
    double sum = 0;
    for (auto s : samples) {
      sum += (double) s * s;
    }
    return std::sqrt(sum / samples.size());
  }
  /**
   * @brief Magnitude spectrum of a Hann-windowed block, zero-padded to a power of two.
   *
   * @param samples Samples.
   * @param size Receives the FFT size.
   * @return Magnitude of bins 0 to size / 2.
   */
  inline std::vector<double> spectrum(std::span<const float> samples, std::size_t &size) {
    size = 1;
    while (size < samples.size()) {
      size <<= 1;
    }
    std::vector<std::complex<double>> a(size);
    for (std::size_t i = 0; i < samples.size(); ++i) {
      const double w = 0.5 - 0.5 * std::cos(2 * std::numbers::pi * i / (samples.size() - 1));
      a[i] = samples[i] * w;
    }
    for (std::size_t i = 1, j = 0; i < size; ++i) {
      std::size_t bit = size >> 1;
      for (; j & bit; bit >>= 1) {
        j ^= bit;
      }
      j ^= bit;
      if (i < j) {
        std::swap(a[i], a[j]);
      }
    }
    for (std::size_t len = 2; len <= size; len <<= 1) {
      const double angle = -2 * std::numbers::pi / len;
      const std::complex<double> wlen {std::cos(angle), std::sin(angle)};
      for (std::size_t i = 0; i < size; i += len) {
        std::complex<double> w {1};
        for (std::size_t j = 0; j < len / 2; ++j) {
          auto u = a[i + j];
          auto v = a[i + j + len / 2] * w;
          a[i + j] = u + v;
          a[i + j + len / 2] = u - v;
          w *= wlen;
        }
      }
    }
    std::vector<double> magnitude(size / 2 + 1);
    for (std::size_t i = 0; i < magnitude.size(); ++i) {
      magnitude[i] = std::abs(a[i]);
    }
    return magnitude;
  }
  /**
   * @brief Frequency of the strongest spectral peak, interpolated between bins.
   *
   * @param samples Samples of one channel.
   * @param sample_rate Sample rate in hertz.
   * @return Frequency in hertz, or 0 for silence.
   */
  inline double dominant_frequency(std::span<const float> samples, double sample_rate) {
    std::size_t size = 0;
    auto magnitude = spectrum(samples, size);
    std::size_t peak = 1;
    for (std::size_t i = 1; i + 1 < magnitude.size(); ++i) {
      if (magnitude[i] > magnitude[peak]) {
        peak = i;
      }
    }
    if (magnitude[peak] <= 1e-9 || peak + 1 >= magnitude.size()) {
      return 0;
    }
    const double l = magnitude[peak - 1];
    const double c = magnitude[peak];
    const double r = magnitude[peak + 1];
    const double denominator = l - 2 * c + r;
    const double offset = denominator == 0 ? 0 : 0.5 * (l - r) / denominator;
    return (peak + offset) * sample_rate / size;
  }
  /**
   * @brief Spectral magnitude near a frequency relative to the strongest peak, in dB.
   *
   * @param samples Samples of one channel.
   * @param sample_rate Sample rate in hertz.
   * @param frequency Frequency to look at.
   * @return Level of the strongest bin within 3 bins of `frequency`, relative to the overall peak.
   */
  inline double relative_level_db(std::span<const float> samples, double sample_rate, double frequency) {
    std::size_t size = 0;
    auto magnitude = spectrum(samples, size);
    const auto peak = *std::max_element(magnitude.begin() + 1, magnitude.end());
    const auto bin = (std::size_t) std::lround(frequency * size / sample_rate);
    double level = 0;
    for (std::size_t i = bin > 3 ? bin - 3 : 1; i <= std::min(bin + 3, magnitude.size() - 1); ++i) {
      level = std::max(level, magnitude[i]);
    }
    return 20 * std::log10(std::max(level, 1e-12) / peak);
  }
  /**
   * @brief Generate interleaved signed 16-bit little-endian PCM with a sine per channel.
   *
   * @param frames Frames to generate.
   * @param sample_rate Sample rate in hertz.
   * @param frequencies Frequency of each channel; 0 makes that channel silent.
   * @param amplitude Peak amplitude as a fraction of full scale.
   * @param start_frame Frame index of the first frame, to continue a previous block.
   * @return PCM bytes.
   */
  inline std::vector<std::uint8_t> sine_s16le(std::size_t frames, double sample_rate, const std::vector<double> &frequencies, double amplitude, std::size_t start_frame = 0) {
    std::vector<std::uint8_t> out;
    out.reserve(frames * frequencies.size() * 2);
    for (std::size_t i = 0; i < frames; ++i) {
      for (auto f : frequencies) {
        const double t = (double) (start_frame + i) / sample_rate;
        const auto v = (std::int16_t) std::lround(f == 0 ? 0.0 : amplitude * 32767 * std::sin(2 * std::numbers::pi * f * t));
        out.push_back((std::uint8_t) (v & 0xff));
        out.push_back((std::uint8_t) ((v >> 8) & 0xff));
      }
    }
    return out;
  }
}  // namespace qemu_test