qdrawavaudiodecoder.cpp

Go to the documentation of this file.

// Copyright (C) 2026 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 "qdrawavaudiodecoder_p.h"
 
#include <QtMultimedia/qaudiodecoder.h>
#include <QtMultimedia/qaudiobuffer.h>
#include <QtCore/qdebug.h>
#include <QtCore/qeventloop.h>
#include <QtCore/qfile.h>
#include <QtCore/qiodevice.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qthreadpool.h>
 
#if QT_CONFIG(network)
#  include <QtNetwork/qnetworkaccessmanager.h>
#  include <QtNetwork/qnetworkreply.h>
#  include <QtNetwork/qnetworkrequest.h>
#endif
 
#include <dr_wav.h>
 
QT_BEGIN_NAMESPACE
 
Q_STATIC_LOGGING_CATEGORY(qLcDrWavDecoder, "qt.multimedia.drwavdecoder")
 
namespace QtMultimediaPrivate {
 
static QDrWavDecodeResult makeFormatError(const QString &message)
{
    return q23::unexpected(std::pair(QAudioDecoder::FormatError, message));
}
 
static QDrWavDecodeResult makeResourceError(const QString &message)
{
    return q23::unexpected(std::pair(QAudioDecoder::ResourceError, message));
}
 
QDrWavDecodeResult loadWaveAndDecodeData(QSpan<const std::byte> data,
                                         const QAudioFormat &requestedFormat)
{
    using namespace QtPrivate;
 
    drwav wav;
    if (!drwav_init_memory(&wav, data.data(), data.size(), nullptr)) {
        qCDebug(qLcDrWavDecoder) << "Failed to initialize dr_wav decoder";
        return makeFormatError(QAudioDecoder::tr("Unable to decode audio file"));
    }
 
    auto cleanup = qScopeGuard([&] {
        drwav_uninit(&wav);
    });
 
    // Determine output format
    QAudioFormat outputFormat;
    size_t bytesPerFrame;
 
    if (requestedFormat.isValid()) {
        // User set a format - check compatibility with file
        if (requestedFormat.sampleRate() != static_cast<int>(wav.sampleRate))
            return makeFormatError(
                    QAudioDecoder::tr("Audio file sample rate does not match requested format"));
        if (requestedFormat.channelCount() != static_cast<int>(wav.channels))
            return makeFormatError(
                    QAudioDecoder::tr("Audio file channel count does not match requested format"));
        outputFormat = requestedFormat;
 
        // Determine bytes per frame based on requested format
        switch (requestedFormat.sampleFormat()) {
        case QAudioFormat::UInt8:
            bytesPerFrame = wav.channels * sizeof(uint8_t);
            break;
        case QAudioFormat::Int16:
            bytesPerFrame = wav.channels * sizeof(int16_t);
            break;
        case QAudioFormat::Int32:
            bytesPerFrame = wav.channels * sizeof(int32_t);
            break;
        case QAudioFormat::Float:
            bytesPerFrame = wav.channels * sizeof(float);
            break;
        default:
            return makeFormatError(QAudioDecoder::tr("Unsupported sample format"));
        }
    } else {
        // Infer format from file header - use native format heuristic
        QAudioFormat::SampleFormat sampleFormat;
 
        switch (wav.bitsPerSample) {
        case 8:
            sampleFormat = QAudioFormat::UInt8;
            bytesPerFrame = wav.channels * sizeof(uint8_t);
            break;
        case 16:
            sampleFormat = QAudioFormat::Int16;
            bytesPerFrame = wav.channels * sizeof(int16_t);
            break;
        case 24: // 24-bit → read as Int32
            sampleFormat = QAudioFormat::Int32;
            bytesPerFrame = wav.channels * sizeof(int32_t);
            break;
        case 32:
            sampleFormat = QAudioFormat::Int32;
            bytesPerFrame = wav.channels * sizeof(int32_t);
            break;
        default: // unsupported → fallback Float
            sampleFormat = QAudioFormat::Float;
            bytesPerFrame = wav.channels * sizeof(float);
            break;
        }
 
        outputFormat.setChannelCount(wav.channels);
        outputFormat.setSampleFormat(sampleFormat);
        outputFormat.setSampleRate(wav.sampleRate);
        outputFormat.setChannelConfig(
                QAudioFormat::defaultChannelConfigForChannelCount(wav.channels));
    }
 
    qCDebug(qLcDrWavDecoder) << "Decoded WAV:"
                             << "channels=" << wav.channels << "sampleRate=" << wav.sampleRate
                             << "bitsPerSample=" << wav.bitsPerSample
                             << "totalPCMFrameCount=" << wav.totalPCMFrameCount
                             << "outputFormat=" << outputFormat.sampleFormat();
 
    const QAudioFormat::SampleFormat readFormat = outputFormat.sampleFormat();
    switch (readFormat) {
    case QAudioFormat::UInt8:
    case QAudioFormat::Int16:
    case QAudioFormat::Int32:
    case QAudioFormat::Float:
        break;
    default:
        return makeFormatError(QAudioDecoder::tr("Unsupported sample format"));
    }
 
    std::optional<QByteArray> decoded = readFramesInChunks(
            wav.totalPCMFrameCount, bytesPerFrame, [&](uint64_t frameCount, char *out) -> uint64_t {
        switch (readFormat) {
        case QAudioFormat::UInt8:
            return drwav_read_pcm_frames(&wav, frameCount, out);
        case QAudioFormat::Int16:
            return drwav_read_pcm_frames_s16(&wav, frameCount, reinterpret_cast<int16_t *>(out));
        case QAudioFormat::Int32:
            return drwav_read_pcm_frames_s32(&wav, frameCount, reinterpret_cast<int32_t *>(out));
        case QAudioFormat::Float:
            return drwav_read_pcm_frames_f32(&wav, frameCount, reinterpret_cast<float *>(out));
        default:
            Q_UNREACHABLE_RETURN(0);
        }
    });
 
    if (!decoded) {
        qCDebug(qLcDrWavDecoder) << "Failed to read all frames:"
                                 << "expected" << wav.totalPCMFrameCount;
        return makeFormatError(QAudioDecoder::tr("Unable to read audio data"));
    }
 
    const QByteArray &pcmData = *decoded;
 
    QAudioBuffer buffer(pcmData, outputFormat);
    if (!buffer.isValid()) {
        return makeFormatError(QAudioDecoder::tr("Failed to create audio buffer"));
    }
 
    qCDebug(qLcDrWavDecoder) << "Successfully decoded:" << buffer.sampleCount() << "samples";
 
    return buffer;
}
 
} // namespace QtMultimediaPrivate
 
QDrWavAudioDecoder::QDrWavAudioDecoder(QAudioDecoder *parent)
    : QPlatformAudioDecoder(parent)
{
}
 
QDrWavAudioDecoder::~QDrWavAudioDecoder()
{
    stop();
}
 
void QDrWavAudioDecoder::setSource(const QUrl &fileName)
{
    stop();
    m_sourceDevice = nullptr;
    if (std::exchange(m_source, fileName) != fileName)
        sourceChanged();
}
 
void QDrWavAudioDecoder::setSourceDevice(QIODevice *device)
{
    stop();
    m_source.clear();
    if (std::exchange(m_sourceDevice, device) != device)
        sourceChanged();
}
 
void QDrWavAudioDecoder::setAudioFormat(const QAudioFormat &format)
{
    if (isDecoding())
        return;
    m_audioFormat = format;
}
 
 
void QDrWavAudioDecoder::start()
{
    if (isDecoding())
        return;
 
    if (m_source.isEmpty() && !m_sourceDevice) {
        error(QAudioDecoder::ResourceError, tr("No audio source specified"));
        return;
    }
 
    m_decodingStopped = std::make_shared<std::atomic_bool>(false);
 
    auto threadPool = QThreadPool::globalInstance();
    threadPool->start([source = m_source, sourceDevice = m_sourceDevice,
                       requestedFormat = m_audioFormat, decodingStopped = m_decodingStopped, this] {
        auto state = loadAndDecodeFile(source, sourceDevice, requestedFormat, decodingStopped);
 
        QMetaObject::invokeMethod(this,
                                  [this, decodingStopped, state = std::move(state)]() mutable {
            if (*decodingStopped) {
                qCDebug(qLcDrWavDecoder) << "Decoding was stopped, discarding result";
                return;
            }
            onDecodeFinished(std::move(state), *decodingStopped);
        });
    });
}
 
void QDrWavAudioDecoder::stop()
{
    if (!isDecoding())
        return;
 
    qCDebug(qLcDrWavDecoder) << "stop() called";
 
    // Prevent the continuation from delivering the buffer
    if (m_decodingStopped) {
        *m_decodingStopped = true;
        m_decodingStopped.reset();
    }
 
    m_buffer = QAudioBuffer();
    finished();
}
 
QAudioBuffer QDrWavAudioDecoder::read()
{
    if (m_buffer.isValid()) {
        QAudioBuffer buffer = std::exchange(m_buffer, QAudioBuffer());
        positionChanged(duration());
        bufferAvailableChanged(false);
        return buffer;
    }
    return QAudioBuffer();
}
 
auto QDrWavAudioDecoder::loadAndDecodeFile(const QUrl &source, QIODevice *sourceDevice,
                                           const QAudioFormat &requestedFormat,
                                           std::shared_ptr<std::atomic_bool> decodingStopped)
        -> QDrWavDecodeResult
{
    using namespace QtMultimediaPrivate;
 
    QByteArray fileData;
 
    // Load file data based on source type
    if (!source.isEmpty()) {
        QString scheme = source.scheme();
 
        if (scheme.isEmpty() || scheme == u"file") {
            // Local file
            QString filePath = source.isLocalFile() ? source.toLocalFile()
                                                    : source.path();
            QFile file(filePath);
            if (!file.open(QFile::ReadOnly))
                return makeResourceError(QAudioDecoder::tr("Cannot open audio file"));
            fileData = file.readAll();
        } else if (scheme == u"qrc") {
            // QRC resource
            QString filePath = u":" + source.toString(QUrl::RemoveScheme);
            QFile file(filePath);
            if (!file.open(QFile::ReadOnly))
                return makeResourceError(QAudioDecoder::tr("Cannot open audio resource"));
            fileData = file.readAll();
        }
#if QT_CONFIG(network)
        else {
            // Network URL
            QNetworkAccessManager networkAccessManager;
            QNetworkReply *reply = networkAccessManager.get(QNetworkRequest(source));
 
            if (reply->error() != QNetworkReply::NoError) {
                reply->deleteLater();
                return makeResourceError(QAudioDecoder::tr("Failed to download audio file"));
            }
 
            // Wait for network reply to finish
            QEventLoop loop;
            QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
            QObject::connect(reply, &QNetworkReply::errorOccurred, &loop, &QEventLoop::quit);
 
            loop.exec();
 
            if (reply->error() != QNetworkReply::NoError) {
                reply->deleteLater();
                return makeResourceError(QAudioDecoder::tr("Network error while downloading audio"));
            }
 
            if (*decodingStopped) {
                reply->deleteLater();
                return QAudioBuffer{};
            }
 
            fileData = reply->readAll();
            reply->deleteLater();
        }
#endif
    } else if (sourceDevice) {
        if (!sourceDevice->isOpen()) {
            if (!sourceDevice->open(QIODevice::ReadOnly))
                return makeResourceError(QAudioDecoder::tr("Cannot open audio device"));
        }
        fileData = sourceDevice->readAll();
    } else {
        return makeResourceError(QAudioDecoder::tr("No audio source specified"));
    }
 
    if (fileData.isEmpty())
        return makeResourceError(QAudioDecoder::tr("Audio file is empty"));
 
    if (*decodingStopped)
        return QAudioBuffer{};
 
    QMetaObject::invokeMethod(this, [this, decodingStopped] {
        if (!*decodingStopped)
            setIsDecoding(true);
    }, Qt::QueuedConnection);
 
    return QtMultimediaPrivate::loadWaveAndDecodeData(
            as_bytes(QSpan{ fileData.constData(), fileData.size() }), requestedFormat);
}
 
void QDrWavAudioDecoder::onDecodeFinished(QDrWavDecodeResult result,
                                          const std::atomic_bool &decodingStopped)
{
    using namespace std::chrono;
    if (!result.has_value()) {
        auto [errorCode, errorString] = result.error();
        error(errorCode, errorString);
        setIsDecoding(false);
        return;
    }
 
    m_buffer = std::move(*result);
    // QAudioBuffer::duration() is in microseconds; convert to milliseconds
    durationChanged(duration_cast<milliseconds>(microseconds{ m_buffer.duration() }));
    positionChanged(0ms);
 
    bufferAvailableChanged(true);
    bufferReady();
    if (decodingStopped)
        return;
 
    finished();
}
 
QT_END_NAMESPACE