QAudioSource Class

QFile destinationFile ; // Membre de classe
QAudioSource* audio ;   // Membre de la classe
{
    destinationFile.setFileName("/tmp/test.raw");
    destinationFile.open( QIODevice::WriteOnly | QIODevice::Truncate);

    QAudioFormat format;
    // Configurer le format souhaité, par exemple :
    format.setSampleRate(44100);
    format.setChannelCount(1);
    format.setSampleFormat(QAudioFormat::Int16);

    QAudioDevice info = QMediaDevices::defaultAudioInput();
    if (!info.isFormatSupported(format)) {
        qWarning() << "Default format not supported, trying to use the nearest.";
    }

    audio = new QAudioSource(format, this);
    connect(audio, &QAudioSource::stateChanged, this, &AudioInputExample::handleStateChanged);

    QTimer::singleShot(3000, this, &AudioInputExample::stopRecording);
    audio->start(&destinationFile);
    // Enregistre le son pendant 3 000 ms
}

void AudioInputExample::stopRecording()
{
    audio->stop();
    destinationFile.close();
    delete audio;
}

QAudioSource* audio ;          // membre de la classe.
std::atomic<float> peakLevel ; // membre de la classe.
{
    QAudioFormat format;
    // Configurer le format, par ex.
    format.setSampleRate(44100);
    format.setChannelCount(2);
    format.setSampleFormat(QAudioFormat::Float);

    QAudioDevice info(QMediaDevices::defaultAudioOutput());
    if (!info.isFormatSupported(format)) {
        qWarning() << "Raw audio format not supported by backend, cannot capture audio.";
       return;
    }

    audio = new QAudioSource(format, this);
    audio->start([&peakLevel] (QSpan<float> interleavedAudioBuffer) {
        float level = peakLevel.load();

        for (float sample : interleavedAudioBuffer) {
            // Calculer le niveau de crête à partir des échantillons audio
            level = std::max(level, std::abs(sample));
        }

        peakLevel.store(level);
        // Remarque : il faut faire attention si le thread de l'application doit être notifié, car la
        // fonction de rappel audio ne doit pas utiliser d'appels système susceptibles de bloquer le système.
       // Les options recommandées sont les événements à réinitialisation automatique (Windows), eventfd (Linux) ou kqueue/EVFILT_USER sur macOS.
    });

    if (!audio->error()== QtAudio::Error::NoError) {
       // Outre les autres signatures de la fonction start(), le lancement de  la fonction  de rappel audio échouera si
        // * le backend n’implémente  pas  d’E/S basées sur des fonctions de rappel (l’API est disponible sur toutes  les  principales
        //   plateformes)
        // * la signature de la fonction de rappel audio ne correspond pas à celle renvoyée par format.sampleFormat()

        qWarning() << "Error starting audio output:" << audio->errorString();
    }
}

void AudioInputExample::handleStateChanged(QtAudio::State newState)
{
    switch (newState) {
        case QtAudio::StoppedState:
            if (audio->error() != QtAudio::NoError) {
                // Error handling
            } else {
                // Finished recording
            }
            break;

        case QtAudio::ActiveState:
            // Started recording - read from IO device
            break;

        default:
            // ... other cases as appropriate
            break;
    }
}

Documentation sur les fonctions membres

[explicit] QAudioSource::QAudioSource(const QAudioFormat &format = QAudioFormat(), QObject *parent = nullptr)

Créez une nouvelle entrée audio et associez-la à ` parent`. Le périphérique d'entrée audio par défaut est utilisé avec les paramètres de sortie ` format `. Si ` format ` est initialisé par défaut, le format sera défini sur le format préféré du périphérique audio.

[explicit] QAudioSource::QAudioSource(const QAudioDevice &audioDevice, const QAudioFormat &format = QAudioFormat(), QObject *parent = nullptr)

Créez une nouvelle entrée audio et associez-la à parent. Le périphérique référencé par audioDevice est utilisé avec les paramètres d'entrée format. Si format est initialisé par défaut, le format sera défini sur le format préféré de audioDevice.

[override virtual noexcept] QAudioSource::~QAudioSource()

Supprimez cette entrée audio.

[since 6.10] qsizetype QAudioSource::bufferFrameCount() const

Renvoie la taille du tampon audio en trames.

Si elle est appelée avant ` start()`, elle renvoie la valeur par défaut de la plateforme. Si elle est appelée avant ` start() `, mais que ` setBufferSize()` ou ` setBufferFrameCount()` a été appelée auparavant, elle renvoie la valeur définie par ` setBufferSize() ` ou ` setBufferFrameCount()`. Si elle est appelée après ` start()`, elle renvoie la taille réelle du tampon actuellement utilisé. Celle-ci peut ne pas correspondre à la valeur précédemment définie par ` setBufferSize() ` ou ` setBufferFrameCount()`.

Cette fonction a été introduite dans Qt 6.10.

Voir également setBufferFrameCount() et bufferSize.

qsizetype QAudioSource::bufferSize() const

Renvoie la taille du tampon audio en octets.

Si la fonction est appelée avant start(), elle renvoie la valeur par défaut de la plate-forme. Si elle est appelée avant start() mais que setBufferSize() ou setBufferFrameCount() a été appelée auparavant, elle renvoie la valeur définie par setBufferSize() ou setBufferFrameCount(). Si elle est appelée après start(), elle renvoie la taille réelle du tampon actuellement utilisé. Celle-ci peut ne pas correspondre à la valeur précédemment définie par setBufferSize() ou setBufferFrameCount().

Voir également setBufferSize() et bufferFrameCount.

qsizetype QAudioSource::bytesAvailable() const

Renvoie la quantité de données audio disponibles pour la lecture, en octets.

Voir également framesAvailable.

qint64 QAudioSource::elapsedUSecs() const

Renvoie le nombre de microsecondes écoulées depuis l'appel de la fonction start(), y compris le temps passé dans les états « Idle » et « Suspend ».

QtAudio::Error QAudioSource::error() const

Renvoie l'état d'erreur.

QAudioFormat QAudioSource::format() const

Renvoie l'QAudioFormat e actuellement utilisé.

[since 6.10] qsizetype QAudioSource::framesAvailable() const

Renvoie la quantité de données audio disponibles pour la lecture, exprimée en trames.

Remarque : la valeur renvoyée n’est valide que lorsque la fonction est dans l’état « QtAudio::ActiveState » ou « QtAudio::IdleState » ; dans le cas contraire, elle renvoie zéro.

Cette fonction a été introduite dans Qt 6.10.

Voir également bytesAvailable.

bool QAudioSource::isNull() const

Renvoie « true » si la source audio est « null », sinon renvoie « false ».

[since 6.12] qsizetype QAudioSource::nativePeriodFrameCount() const

Renvoie le nombre de trames de période natif.

Renvoie -1 si la valeur n'est pas définie, sinon renvoie la valeur précédemment définie avec la fonction setNativePeriodFrameCount().

Cette fonction a été introduite dans Qt 6.12.

Voir aussi setNativePeriodFrameCount.

qint64 QAudioSource::processedUSecs() const

Renvoie, en microsecondes, la quantité de données audio traitées depuis l'appel de la fonction start().

void QAudioSource::reset()

Supprime toutes les données audio contenues dans les tampons et remet les tampons à zéro.

void QAudioSource::resume()

Reprend le traitement des données audio après l'appel de la fonction suspend().

Rétablit l’état de la fonction ` state()` tel qu’il était au moment de l’appel de ` suspend()`. Cette fonction ne fait rien si l’état du périphérique de sortie audio n’est pas ` QtAudio::SuspendedState`.

[since 6.10] void QAudioSource::setBufferFrameCount(qsizetype value)

Définit la taille du tampon audio à value en nombre d'images.

Les propriétés bufferFrameCount() et bufferSize() indiquent la taille du tampon circulaire lors de l’utilisation des API QIODevice. La taille native de la période est contrôlée via setNativePeriodFrameCount().

Cette fonction a été introduite dans Qt 6.10.

Voir également bufferFrameCount() et setBufferSize.

void QAudioSource::setBufferSize(qsizetype value)

Définit la taille du tampon audio à value octets.

Les propriétés bufferFrameCount() et bufferSize() indiquent la taille du tampon circulaire lors de l’utilisation des API QIODevice. La taille native de la période est contrôlée via setNativePeriodFrameCount().

Voir également bufferSize() et setBufferFrameCount.

[since 6.12] void QAudioSource::setNativePeriodFrameCount(qsizetype frameCount)

Définit le nombre de trames par période native à frameCount.

Règle la taille de la mémoire tampon audio utilisée par le système d’exploitation et le matériel. Par défaut (lorsque ce paramètre n’est pas défini), le système utilise une valeur dépendante de la plate-forme, généralement 1 024 trames (~23 ms à 44 100 Hz).

Utilisez des valeurs plus petites (64 à 256) pour réduire la latence, ou des valeurs plus grandes (2048 à 4096) pour réduire le risque de débordement de tampon (pertes de données).

Les valeurs valides sont des puissances de 2 comprises entre 32 et 4 096 (inclus), ou -1 pour désactiver le paramètre. Ne peut être appelé que lorsque la source audio est arrêtée.

Correspond aux paramètres spécifiques à chaque plateforme : kAudioDevicePropertyBufferFrameSize (macOS), IAudioClient::bufferDuration (Windows), PW_KEY_NODE_FORCE_QUANTUM (PipeWire/Linux) et AAudioStreamBuilder_setBufferCapacityInFrames (Android).

Cette fonction a été introduite dans Qt 6.12.

Voir également nativePeriodFrameCount.

void QAudioSource::setVolume(qreal volume)

Règle le volume d'entrée sur volume.

Le volume est mis à l'échelle de manière linéaire entre 0.0 (silence) et 1.0 (volume maximal). Les valeurs situées en dehors de cette plage seront limitées.

Si l'appareil ne prend pas en charge le réglage du volume d'entrée, la valeur volume sera ignorée et le volume d'entrée restera à 1,0.

Le volume par défaut est 1.0.

Voir également volume().

QIODevice *QAudioSource::start()

Renvoie un pointeur vers l'QIODevice interne utilisée pour transférer les données provenant de l'entrée audio du système. Le périphérique sera déjà ouvert et la fonction read() pourra y lire directement les données.

Si l'QAudioSource est en mesure d'accéder au périphérique audio du système, la fonction state() renvoie QtAudio::IdleState, la fonction error() renvoie QtAudio::NoError et le signal stateChanged() est émis.

Si un problème survient au cours de ce processus, la fonction error() renvoie QtAudio::OpenError, la fonction state() renvoie QtAudio::StoppedState et le signal stateChanged() est émis.

Voir également QIODevice et QIODevice interface.

[since 6.11] template <typename Callback> requires QtAudio::if_audio_source_callback<Callback> void QAudioSource::start(Callback &&cb)

Lance l'QAudioSource avec une fonction de rappel qui sera appelée sur un thread audio en temps réel souple. La fonction de rappel est un objet « callable » qui prend en argument un objet de type QSpan<const SampleType> ; le type SampleType doit correspondre à l'QAudioFormat::SampleFormat du format de l'QAudioSource. L'objet span contient les données audio entrelacées.

Si l’ QAudioSource e parvient à démarrer correctement, la fonction error() renvoie QtAudio::NoError.

Si un problème survient au cours de ce processus, la fonction ` error()` renvoie ` QtAudio::OpenError`, la fonction ` state()` renvoie ` QtAudio::StoppedState ` et le signal ` stateChanged()` est émis.

Cette fonction a été introduite dans Qt 6.11.

Voir également Callback interface.

void QAudioSource::start(QIODevice *device)

Lance le transfert des données audio depuis l'entrée audio du système vers l'device. L'device doit avoir été ouvert en mode « WriteOnly », « Append » ou « ReadWrite ».

Si le QAudioSource parvient à récupérer les données audio, state() renvoie soit QtAudio::ActiveState, soit QtAudio::IdleState; error() renvoie QtAudio::NoError et le signal stateChanged() est émis.

Si un problème survient au cours de ce processus, error() renvoie QtAudio::OpenError, state() renvoie QtAudio::StoppedState et le signal stateChanged() est émis.

Voir également QIODevice et QIODevice interface.

QtAudio::State QAudioSource::state() const

Renvoie l'état du traitement audio.

[signal] void QAudioSource::stateChanged(QtAudio::State state)

Ce signal est émis lorsque l'state de l'appareil a changé.

void QAudioSource::stop()

Arrête l'entrée audio et se déconnecte de la ressource système.

Définit error() sur QtAudio::NoError, state() sur QtAudio::StoppedState et émet le signal stateChanged().

void QAudioSource::suspend()

Arrête le traitement des données audio tout en conservant les données audio mises en mémoire tampon.

Définit error() sur QtAudio::NoError, state() sur QtAudio::SuspendedState et émet le signal stateChanged().

qreal QAudioSource::volume() const

Renvoie le volume d'entrée.

Si l'appareil ne prend pas en charge le réglage du volume d'entrée, la valeur renvoyée sera 1,0.

Voir également setVolume().