QAudioSink Class

QFile sourceFile ;  // membre de la classe.
QAudioSink* audio ; // membre de la classe.
{
    sourceFile.setFileName("/tmp/test.raw");
    sourceFile.open(QIODevice::ReadOnly);

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

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

    audio = new QAudioSink(format, this);
    connect(audio, QAudioSink::stateChanged, this, &AudioInputExample::handleStateChanged);
    audio->start(&sourceFile);
}

void AudioOutputExample::stopAudioOutput()
{
    audio->stop();
    sourceFile.close();
    delete audio;
}

QAudioSink* audio ; // membre de la classe.
float phase ;       // membre de la classe.
{
    QAudioFormat format;
    // Configuration du format, par exemple :
    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 play audio.";
       return;
    }

    audio = new QAudioSink(format, this);
    float phaseIncrement = 2 * M_PI * 220.0 / format.sampleRate(); // onde sinusoïdale à 220 Hz
    audio->start([&phase, phaseIncrement] (QSpan<float> interleavedAudioBuffer) {
        // La fonction de rappel audio ne doit appeler aucune fonction susceptible de bloquer l'exécution

        // Remplir le tampon audio avec une onde sinusoïdale
        const int sampleCount = interleavedAudioBuffer.size() / 2; // Stéréo, donc diviser par 2
        for (int i = 0; i < sampleCount;++i) {
            float sample = std::sin(phase);
            interleavedAudioBuffer[i * 2] = sample;     // Canal gauche
            interleavedAudioBuffer[i * 2 + 1] = sample; // Canal droit
            phase+= phaseIncrement;                    // Incrémenter la phase pour l'échantillon suivant
        }
    });

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

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

void AudioOutputExample::handleStateChanged(QtAudio::State newState)
{
    switch (newState) {
        case QtAudio::IdleState:
            // Finished playing (no more data)
            AudioOutputExample::stopAudioOutput();
            break;

        case QtAudio::StoppedState:
            // Stopped for other reasons
            if (audio->error() != QtAudio::NoError) {
                // Error handling
            }
            break;

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

Documentation sur les fonctions membres

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

Créez une nouvelle sortie audio et associez-la à ` parent`. Le périphérique de sortie 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] QAudioSink::QAudioSink(const QAudioDevice &audioDevice, const QAudioFormat &format = QAudioFormat(), QObject *parent = nullptr)

Créez une nouvelle sortie audio et associez-la à parent. Le périphérique référencé par audioDevice 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é de audioDevice.

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

Supprime cette sortie audio.

Cela libérera toutes les ressources système utilisées et tous les tampons.

[since 6.10] qsizetype QAudioSink::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 QAudioSink::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 QAudioSink::bytesFree() const

Renvoie le nombre d'octets libres disponibles dans le tampon audio.

Voir également framesFree.

qint64 QAudioSink::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 QAudioSink::error() const

Renvoie l'état d'erreur.

QAudioFormat QAudioSink::format() const

Renvoie l'QAudioFormat e en cours d'utilisation.

[since 6.10] qsizetype QAudioSink::framesFree() const

Renvoie le nombre de trames libres disponibles dans le tampon audio.

Cette fonction a été introduite dans Qt 6.10.

Voir aussi bytesFree.

bool QAudioSink::isNull() const

Renvoie ` true ` si l'instance ` QAudioSink ` est ` null`, sinon renvoie ` false`.

[since 6.12] qsizetype QAudioSink::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 setNativePeriodFrameCount().

Cette fonction a été introduite dans Qt 6.12.

Voir également setNativePeriodFrameCount.

qint64 QAudioSink::processedUSecs() const

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

void QAudioSink::reset()

Interrompt immédiatement la sortie audio et supprime toutes les données audio actuellement présentes dans les tampons. Toutes les données audio en attente envoyées à ` QIODevice ` sont ignorées.

Voir également stop().

void QAudioSink::resume()

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

Rétablit l'état de la fonction ` state()` à celui que le récepteur avait au moment de l'appel de ` suspend()`. Cette fonction ne fait rien si l'état du récepteur audio n'est pas ` QtAudio::SuspendedState`.

[since 6.10] void QAudioSink::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 QAudioSink::setBufferSize(qsizetype value)

Définit la taille du tampon audio à value en 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 QAudioSink::setNativePeriodFrameCount(qsizetype frameCount)

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

Règle la taille du tampon audio utilisé par le système d'exploitation et le matériel. Par défaut (lorsque cette valeur n'est pas définie), 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 sous-remplissage du tampon (pertes de données).

Les valeurs valides sont des puissances de 2 comprises entre 32 et 4096 (inclus), ou -1 pour désactiver le paramètre. Ne peut être appelé que lorsque le périphérique de sortie audio est arrêté.

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 QAudioSink::setVolume(qreal volume)

Règle le volume de sortie sur volume.

Le volume est modulé 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.

Le volume par défaut est 1.0.

Les commandes de volume de l’interface utilisateur doivent généralement être mises à l’échelle de manière non linéaire. Par exemple, l’utilisation d’une échelle logarithmique produira des changements linéaires dans le niveau sonore perçu, ce à quoi un utilisateur s’attend normalement de la part d’une commande de volume. Voir QtAudio::convertVolume() pour plus de détails.

Voir également volume().

QIODevice *QAudioSink::start()

Renvoie un pointeur vers l'QIODevice interne utilisé pour transférer les données vers la sortie audio du système. Le périphérique sera déjà ouvert et la fonction write() pourra y écrire directement des données.

Si l'QAudioSink est en mesure d'accéder au périphérique audio du système, state() renvoie QtAudio::IdleState, 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_sink_callback<Callback> void QAudioSink::start(Callback &&cb)

Lance l'QAudioSink 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 « QSpan » de type <SampleType> ; ce type doit correspondre à l'QAudioFormat::SampleFormat du format de l'QAudioSink. La plage doit être remplie de données audio entrelacées.

Si l’ QAudioSink ion 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 QAudioSink::start(QIODevice *device)

Lance le transfert des données audio depuis l'device vers la sortie audio du système. L'device doit avoir été ouvert en mode « ReadOnly » ou « ReadWrite ».

Si l'QAudioSink parvient à émettre correctement des données audio, la fonction state() renvoie QtAudio::ActiveState, 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.

QtAudio::State QAudioSink::state() const

Renvoie l'état du traitement audio.

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

Ce signal est émis lorsque la propriété state de l'appareil a changé. Il s'agit de l'état actuel de la sortie audio.

void QAudioSink::stop()

Arrête la sortie 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().

Voir également reset().

void QAudioSink::suspend()

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

Définit la fonction ` state()` sur ` QtAudio::SuspendedState ` et émet le signal ` stateChanged()`.

qreal QAudioSink::volume() const

Renvoie le volume compris entre 0,0 et 1,0 inclus.

Voir aussi setVolume().