qaudioformat.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 <QDebug>
#include <qaudioformat.h>
#include <qalgorithms.h>
 
QT_BEGIN_NAMESPACE
 
void QAudioFormat::setChannelConfig(ChannelConfig config) noexcept
{
    m_channelConfig = config;
    if (config != ChannelConfigUnknown)
        m_channelCount = qPopulationCount(config);
}
 
int QAudioFormat::channelOffset(AudioChannelPosition channel) const noexcept
{
    if (!(m_channelConfig & (1u << channel)))
        return -1;
 
    uint maskedChannels = m_channelConfig & ((1u << channel) - 1);
    return qPopulationCount(maskedChannels);
}
 
qint32 QAudioFormat::bytesForDuration(qint64 microseconds) const
{
    return bytesPerFrame() * framesForDuration(microseconds);
}
 
qint64 QAudioFormat::durationForBytes(qint32 bytes) const
{
    // avoid compiler warnings about unused variables. [[maybe_unused]] in the header
    // gives compiler errors on older gcc versions
    Q_UNUSED(reserved);
 
    if (!isValid() || bytes <= 0)
        return 0;
 
    // We round the byte count to ensure whole frames
    return qint64(1000000LL * (bytes / bytesPerFrame())) / sampleRate();
}
 
qint32 QAudioFormat::bytesForFrames(qint32 frameCount) const
{
    return frameCount * bytesPerFrame();
}
 
qint32 QAudioFormat::framesForBytes(qint32 byteCount) const
{
    int size = bytesPerFrame();
    if (size > 0)
        return byteCount / size;
    return 0;
}
 
qint32 QAudioFormat::framesForDuration(qint64 microseconds) const
{
    if (!isValid())
        return 0;
 
    return qint32((microseconds * sampleRate()) / 1000000LL);
}
 
qint64 QAudioFormat::durationForFrames(qint32 frameCount) const
{
    if (!isValid() || frameCount <= 0)
        return 0;
 
    return (frameCount * 1000000LL) / sampleRate();
}
 
float QAudioFormat::normalizedSampleValue(const void *sample) const
{
    switch (m_sampleFormat) {
    case UInt8:
        return ((float)*reinterpret_cast<const quint8 *>(sample))
                / (float)std::numeric_limits<qint8>::max()
                - 1.;
    case Int16:
        return ((float)*reinterpret_cast<const qint16 *>(sample))
                / (float)std::numeric_limits<qint16>::max();
    case Int32:
        return ((float)*reinterpret_cast<const qint32 *>(sample))
                / (float)std::numeric_limits<qint32>::max();
    case Float:
        return *reinterpret_cast<const float *>(sample);
    case Unknown:
    case NSampleFormats:
        break;
    }
 
    return 0.;
}
 
QAudioFormat::ChannelConfig QAudioFormat::defaultChannelConfigForChannelCount(int channelCount)
{
    QAudioFormat::ChannelConfig config;
    switch (channelCount) {
    case 0:
        config = QAudioFormat::ChannelConfigUnknown;
        break;
    case 1:
        config = QAudioFormat::ChannelConfigMono;
        break;
    case 2:
        config = QAudioFormat::ChannelConfigStereo;
        break;
    case 3:
        config = QAudioFormat::ChannelConfig2Dot1;
        break;
    case 4:
        config = QAudioFormat::channelConfig(QAudioFormat::FrontLeft, QAudioFormat::FrontRight,
                                             QAudioFormat::BackLeft, QAudioFormat::BackRight);
        break;
    case 5:
        config = QAudioFormat::ChannelConfigSurround5Dot0;
        break;
    case 6:
        config = QAudioFormat::ChannelConfigSurround5Dot1;
        break;
    case 7:
        config = QAudioFormat::ChannelConfigSurround7Dot0;
        break;
    case 8:
        config = QAudioFormat::ChannelConfigSurround7Dot1;
        break;
    default:
        // give up, simply use the first n channels
        config = QAudioFormat::ChannelConfig((1 << (channelCount + 1)) - 1);
    }
    return config;
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, QAudioFormat::SampleFormat type)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace();
    switch (type) {
    case QAudioFormat::UInt8:
        dbg << "UInt8";
        break;
    case QAudioFormat::Int16:
        dbg << "Int16";
        break;
    case QAudioFormat::Int32:
        dbg << "Int32";
        break;
    case QAudioFormat::Float:
        dbg << "Float";
        break;
    default:
        dbg << "Unknown";
        break;
    }
    return dbg;
}
 
QDebug operator<<(QDebug dbg, const QAudioFormat &f)
{
    dbg << "QAudioFormat(" << f.sampleRate() << "Hz, " << f.channelCount() << "Channels, "
        << f.sampleFormat() << "Format )";
    return dbg;
}
#endif
 
QT_END_NAMESPACE