Présentation audio

Fonctionnalités audio

Qt Multimedia propose une gamme de cours sur l'audio couvrant à la fois les approches de bas niveau et de haut niveau en matière d'entrée, de sortie et de traitement audio.

Détails de mise en œuvre audio

Lecture de fichiers audio compressés

Pour lire des fichiers multimédias ou audio qui ne sont pas de simples fichiers audio non compressés, vous pouvez utiliser la classe C++ ` QMediaPlayer ` ou le type QML ` MediaPlayer `. La classe ` QMediaPlayer ` et les types QML associés permettent également de lire des vidéos, si nécessaire.

Pour plus de détails, consultez la section Formats multimédias pris en charge.

Le lecteur multimédia doit être connecté à un objet QAudioOutput (ou à l’élément QML AudioOutput ) pour lire des fichiers audio.

Voici comment lire un fichier local en C++ :

player = new QMediaPlayer;
audioOutput = new QAudioOutput;
player->setAudioOutput(audioOutput);
// ...
player->setSource(QUrl::fromLocalFile("/Users/me/Music/coolsong.mp3"));
audioOutput->setVolume(0.5);
player->play();

La même fonctionnalité en QML :

MediaPlayer {
    audioOutput: AudioOutput {}
    source: "file:///path/to/my/music.mp3"
    Component.onCompleted: { play() }
}

Enregistrement audio dans un fichier

Pour enregistrer du son dans un fichier, vous devez créer une session de capture et y associer une entrée audio et un enregistreur. Ces éléments sont implémentés à l’aide des classes ` QMediaCaptureSession`, ` QAudioInput` et ` QMediaRecorder `. L’instance par défaut de ` QAudioInput ` sélectionne l’entrée audio par défaut du système. L’enregistreur contrôle le processus d’enregistrement à l’aide de simples fonctions record() et stop(). De plus, vous pouvez l’utiliser pour sélectionner l’emplacement de sortie, l’encodeur audio ou le format du conteneur de fichiers.

Une session d’enregistrement audio à partir du microphone par défaut se présenterait comme suit en C++ :

QMediaCaptureSession session;
QAudioInput audioInput;
session.setAudioInput(&audioInput);
QMediaRecorder recorder;
session.setRecorder(&recorder);
recorder.setQuality(QMediaRecorder::HighQuality);
recorder.setOutputLocation(QUrl::fromLocalFile("test.mp3"));
recorder.record();

En QML, on peut obtenir le même résultat ainsi :

CaptureSession {
    audioInput: AudioInput {}
    mediaRecorder: MediaRecorder {
        id: recorder
        outputLocation: "file:///path/to/test.mp3"
    }
    Component.onCompleted: { recorder.record() }
}

QMediaCaptureSession prend également en charge des cas d’utilisation plus complexes, tels que la capture d’images ou l’enregistrement vidéo.

Effets sonores à faible latence

Outre l'accès brut aux périphériques audio, la classe QSoundEffect (et le type QML SoundEffect ) offre une méthode plus abstraite pour lire des sons. Cette classe vous permet de spécifier un fichier au format WAV, qui peut ensuite être lu avec une faible latence si nécessaire.

Vous pouvez régler :

• Number of loops dans lequel un effet sonore est lu.
• Volume de l'effet sonore.
• Muting de l’effet sonore.

Entrée et sortie audio à faible niveau

L'API C++ d'Qt Multimedia propose des classes permettant un accès brut aux fonctionnalités d'entrée et de sortie audio, ce qui permet aux applications de recevoir des données brutes provenant de périphériques tels que des microphones, et d'écrire des données brutes vers des haut-parleurs ou d'autres périphériques. En général, ces classes n'effectuent aucun décodage audio ni aucun autre traitement, mais elles peuvent prendre en charge différents types de données audio brutes.

La classe ` QAudioSink ` permet la sortie de données audio brutes, tandis que ` QAudioSource ` permet l’entrée de données audio brutes. Le matériel disponible détermine les entrées et sorties audio disponibles.

Push et Pull à l’aide de QIODevice

Les classes audio de bas niveau peuvent fonctionner selon deux modes : « push » et « pull ». En mode « pull », le périphérique audio est démarré en lui transmettant une valeur « QIODevice ». Pour un périphérique de sortie, la classe « QAudioSink » récupère les données depuis le « QIODevice » (à l’aide de « QIODevice::read()») lorsque davantage de données audio sont requises. À l’inverse, en mode « pull » avec « QAudioSource », lorsque des données audio sont disponibles, celles-ci sont directement écrites dans le « QIODevice ».

En mode « push », le périphérique audio fournit une instance de type ` QIODevice ` sur laquelle il est possible d'écrire ou de lire selon les besoins.

Interface basée sur les callbacks

Outre l’utilisation d’une interface basée sur l’ QIODevice, les classes audio de bas niveau fournissent une interface basée sur les callbacks qui permet aux utilisateurs d’enregistrer un callback appelé sur le thread audio chaque fois que le périphérique audio a besoin de données supplémentaires ou en transmet. Cela permet un traitement audio à très faible latence, car l’application peut traiter les données directement sur le thread audio.

{
    QAudioFormat format;
    // Configurer le 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) {
        // Le callback audio ne doit appeler aucune fonction susceptible d'être bloquante

        // Remplir le tampon audio avec une onde sinusoïdale
        const int sampleCount = interleavedAudioBuffer.size() / 2; // Son 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 la fonction 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 de la fonction de rappel audio ne correspond pas à celle renvoyée par format.sampleFormat()

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

Décodage de l’audio compressé en mémoire

Dans certains cas, vous pouvez souhaiter décoder un fichier audio compressé et effectuer vous-même un traitement supplémentaire. Par exemple, pour mixer plusieurs échantillons ou utiliser des algorithmes personnalisés de traitement du signal numérique. « QAudioDecoder » prend en charge le décodage de fichiers locaux ou de flux de données provenant d’instances « QIODevice ».

Voici un exemple de décodage d’un fichier local :

QAudioFormat desiredFormat;
desiredFormat.setChannelCount(2);
desiredFormat.setSampleFormat(QAudioFormat::Int16);
desiredFormat.setSampleRate(48000);

QAudioDecoder *decoder = new QAudioDecoder(this);
decoder->setAudioFormat(desiredFormat);
decoder->setSource("level1.mp3");

connect(decoder, &QAudioDecoder::bufferReady, this, &AudioDecodingExample::readBuffer);
decoder->start();

// Now wait for bufferReady() signal and call decoder->read()

Audio spatial

Le Qt Spatial Audio module fournit une API permettant de mettre en œuvre des champs sonores dans un espace 3D.

Documentation de référence

Classes C++

Types QML

Exemples