Revision control

++ // Copyright (C) 2025 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "qqnxsndaudiodevice_p.h"
++ #include "qqnxsndhelpers_p.h"
++
++ #include <QtMultimedia/private/qaudioformat_p.h>
++
++ #include <alsa/asoundlib.h>
++
++ #include <QtCore/qloggingcategory.h>
++
++ #include <algorithm>
++
++ QT_BEGIN_NAMESPACE
++
++ // lcQnxSndDevices is declared in qqnxsndaudiodevice_p.h and defined in
++ // qqnxsndaudiodevices.cpp; the device-info and enumeration TUs share it.
++
++ namespace {
++
++ // Conservative format returned when the device's parameter space can't be probed.
++ // io-snd is non-exclusive, so any openable device is probed for its real caps; this
++ // is reached only for a hint-reported phantom with no backing hardware (whose device
++ // is then discarded by the /dev/snd cross-check in qqnxsndaudiodevices.cpp) and for
++ // the offline unit test, which uses a non-openable id to exercise this path.
++ QAudioDevicePrivate::AudioDeviceFormat defaultDeviceFormat(QAudioDevice::Mode mode)
++ {
++ QAudioDevicePrivate::AudioDeviceFormat format;
++
++ format.minimumChannelCount = 1;
++ format.maximumChannelCount = 2;
++
++ format.minimumSampleRate = 8000;
++ format.maximumSampleRate = 48000;
++
++ format.supportedSampleFormats = {
++ QAudioFormat::UInt8,
++ QAudioFormat::Int16,
++ QAudioFormat::Int32,
++ QAudioFormat::Float,
++ };
++
++ format.preferredFormat.setChannelCount(mode == QAudioDevice::Input ? 1 : 2);
++ format.preferredFormat.setSampleFormat(QAudioFormat::Float);
++ format.preferredFormat.setSampleRate(48000);
++
++ return format;
++ }
++
++ // Query the device's real capabilities by opening it and inspecting the ALSA
++ // hw_params space, in the spirit of the WASAPI backend's IsFormatSupported probe.
++ // SALSA on QNX has no plugin/resampling layer, so the hint-reported format must
++ // reflect what the hardware actually accepts. On any failure we fall back to the
++ // conservative defaults rather than dropping the device.
++ QAudioDevicePrivate::AudioDeviceFormat probeDeviceFormat(const QByteArray &dev,
++ QAudioDevice::Mode mode)
++ {
++ QAudioDevicePrivate::AudioDeviceFormat format = defaultDeviceFormat(mode);
++
++ const snd_pcm_stream_t direction =
++ mode == QAudioDevice::Input ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK;
++
++ // Non-blocking open: probing only reads the parameter space and must never
++ // stall enumeration if the device is busy.
++ snd_pcm_t *handle = nullptr;
++ if (int err = snd_pcm_open(&handle, dev.constData(), direction, SND_PCM_NONBLOCK); err < 0) {
++ qCDebug(lcQnxSndDevices) << "probe: cannot open" << dev << ":" << snd_strerror(err)
++ << "- using default format";
++ return format;
++ }
++
++ snd_pcm_hw_params_t *hwparams;
++ snd_pcm_hw_params_alloca(&hwparams);
++ if (int err = snd_pcm_hw_params_any(handle, hwparams); err < 0) {
++ qCDebug(lcQnxSndDevices) << "probe: hw_params_any failed for" << dev << ":"
++ << snd_strerror(err) << "- using default format";
++ snd_pcm_close(handle);
++ return format;
++ }
++
++ // Sample rate range: test the standard rates against the device and keep the
++ // span of supported ones. (get_rate_max reports an unbounded value on io-snd.)
++ QList<int> supportedRates;
++ for (int rate : QtMultimediaPrivate::allSupportedSampleRates) {
++ if (snd_pcm_hw_params_test_rate(handle, hwparams, static_cast<unsigned>(rate), 0) == 0)
++ supportedRates.append(rate);
++ }
++ if (!supportedRates.isEmpty()) {
++ // allSupportedSampleRates is ascending, so first/last bound the range.
++ format.minimumSampleRate = supportedRates.first();
++ format.maximumSampleRate = supportedRates.last();
++ }
++
++ // io-snd converts sample formats internally; combined with the backend's
++ // "always best-native + convert" open strategy (see openConfiguredPcm), every
++ // QAudioFormat sample format is usable regardless of the device's native
++ // format, so advertise them all. The probe below is kept only to report the
++ // device-native formats in the debug log.
++ QList<QAudioFormat::SampleFormat> nativeFormats;
++ for (QAudioFormat::SampleFormat sf : { QAudioFormat::UInt8, QAudioFormat::Int16,
++ QAudioFormat::Int32, QAudioFormat::Float }) {
++ const snd_pcm_format_t pcmFormat = QnxSndHelpers::mapSampleFormat(sf);
++ if (pcmFormat != SND_PCM_FORMAT_UNKNOWN
++ && snd_pcm_hw_params_test_format(handle, hwparams, pcmFormat) == 0) {
++ nativeFormats.append(sf);
++ }
++ }
++ format.supportedSampleFormats = qAllSupportedSampleFormats();
++
++ // Channel count range.
++ unsigned int minChannels = 0;
++ unsigned int maxChannels = 0;
++ if (snd_pcm_hw_params_get_channels_min(hwparams, &minChannels) == 0
++ && snd_pcm_hw_params_get_channels_max(hwparams, &maxChannels) == 0 && maxChannels > 0) {
++ format.minimumChannelCount = static_cast<int>(minChannels);
++ format.maximumChannelCount = static_cast<int>(maxChannels);
++ }
++
++ // Float is always usable (converted to the device-native format on open), so
++ // it is the preferred application format.
++ format.preferredFormat.setSampleFormat(QAudioFormat::Float);
++
++ // Prefer 48 kHz, else the supported rate closest to it (logarithmic distance).
++ const int preferredRate = supportedRates.isEmpty()
++ ? ((48000 >= format.minimumSampleRate && 48000 <= format.maximumSampleRate)
++ ? 48000
++ : format.maximumSampleRate)
++ : QtMultimediaPrivate::findClosestSamplingRate(48000, QSpan<const int>{ supportedRates });
++ format.preferredFormat.setSampleRate(preferredRate);
++
++ const int preferredChannels = mode == QAudioDevice::Input ? 1 : 2;
++ format.preferredFormat.setChannelCount(
++ std::clamp(preferredChannels, format.minimumChannelCount, format.maximumChannelCount));
++
++ if (const int err = snd_pcm_close(handle); err < 0)
++ qCDebug(lcQnxSndDevices) << "probe: snd_pcm_close failed:" << snd_strerror(err);
++
++ qCDebug(lcQnxSndDevices) << "probe:" << dev << "rate" << format.minimumSampleRate << "-"
++ << format.maximumSampleRate << "ch" << format.minimumChannelCount << "-"
++ << format.maximumChannelCount << "native formats" << nativeFormats
++ << "(advertising all)";
++ return format;
++ }
++
++ } // namespace
++
++ QQnxSndAudioDeviceInfo::QQnxSndAudioDeviceInfo(const QByteArray &dev, const QString &desc,
++ QAudioDevice::Mode mode)
++ : QAudioDevicePrivate(dev, mode, desc, false, probeDeviceFormat(dev, mode))
++ {
++ }
++
++ QQnxSndAudioDeviceInfo::~QQnxSndAudioDeviceInfo() = default;
++
++ QT_END_NAMESPACE