Exemples audio en fonction du niveau sonore

La mise en œuvre de cet exemple repose sur les widgets. Pour plus d’informations à ce sujet, consultez la section « Premiers pas en programmation avec Qt Widgets ». Les sections suivantes expliquent comment utiliser l’API Qt Charts pour afficher des données dynamiques sur un graphique représentant les échantillons en fonction du niveau sonore. Pour plus d’informations sur l’échantillonnage, consultez la page Échantillonnage (traitement du signal).

Exécution de l’exemple

Vous pouvez exécuter l’exemple à partir de :

• Qt Creator

  Ouvrez le mode « Welcome » et sélectionnez l’exemple dans « Examples ». Pour plus d’informations, consultez « Qt Creator: Tutoriel : Compiler et exécuter ».

• Qt Extension for Visual Studio Code

  Exécutez la commande « Qt: Open Qt examples » à partir de Command Palette, puis sélectionnez l’exemple dans la liste. Pour plus d’informations, consultez Qt Extension for Visual Studio Code: Tutoriel : Compiler et exécuter.

Récupération des données audio

Grâce à l’intégration du module Qt Multimedia dans main.cpp, nous créons un nouvel objet QAudioDevice qui représente le périphérique audio par défaut de la plateforme cible. Nous vérifions également la présence d’un périphérique d’entrée audio et informons l’utilisateur si aucun périphérique d’entrée audio n’est disponible.

    if (inputDevice.isNull()) {
        QMessageBox::warning(nullptr, "audio",
                             "There is no audio input device available.");
        return -1;
    }

Le périphérique audio est ensuite transmis au widget w via l’argument de son constructeur w. La méthode w.show() est ensuite appelée pour afficher le widget.

    Widget w(inputDevice);
    w.resize(800, 600);
    w.show();

Configuration du graphique

Cette section traite de la configuration du graphique et des axes.

Dans ` widget.cpp`, le constructeur `Widget` réimplémenté se charge de l'essentiel de la logique de l'application. Les objets `QChart`, `QLineSeries` et `QChartView` sont déclarés comme suit :

    : QWidget(parent)
    , m_chart(new QChart)
    , m_series(new QLineSeries)
{
    auto chartView = new QChartView(m_chart);
    m_chart->addSeries(m_series);

m_series sert à utiliser les données d'entrée audio.

L'axe des x « Samples »

Nous définissons la plage minimale et maximale de l’axe des x de 0 à XYSeriesIODevice::sampleCount. (Déclarée dans xyseriesiodevice.h comme étant 2000). Nous définissons ensuite le texte de son titre.

    auto axisX = new QValueAxis;
    axisX->setRange(0, XYSeriesIODevice::sampleCount);
    axisX->setLabelFormat("%g");
    axisX->setTitleText("Samples");

L’axe des y « Niveau audio »

Nous créons l’ axisY QValueAxis, définissons son intervalle et son titre.

    auto axisY = new QValueAxis;
    axisY->setRange(-1, 1);
    axisY->setTitleText("Audio level");

Ajout des axes et définition du titre du graphique

Nous attachons les axes, masquons la légende et définissons le titre du graphique pour qu’il inclue le nom du microphone utilisé comme entrée audio.

    m_chart->addAxis(axisX, Qt::AlignBottom);
    m_series->attachAxis(axisX);
    m_chart->addAxis(axisY, Qt::AlignLeft);
    m_series->attachAxis(axisY);
    m_chart->legend()->hide();

Mise en page du graphique

Nous utilisons ici un QVBoxLayout mainLayout et ajoutons notre QChartview chartView à la disposition verticale.

    m_chart->setTitle("Data from the microphone (" + deviceInfo.description() + ')');

    auto mainLayout = new QVBoxLayout(this);

Utilisation des données d’entrée audio

Cette section montre comment les données du microphone sont transmises à la classe `QLineSeries` m_series. Comme précédemment, cela repose sur le module Qt Multimedia.

Nous transmettons d'abord deviceInfo au constructeur de QAudioInput.

    mainLayout->addWidget(chartView);

    m_audioInput = new QAudioInput(deviceInfo, this);

    QAudioFormat formatAudio;

Nous configurons ensuite notre QAudioFormat formatAudio , en définissant le nombre de canaux, la fréquence d’échantillonnage et le format d’échantillonnage.

    formatAudio.setSampleRate(8000);
    formatAudio.setChannelCount(1);

Nous pouvons désormais créer un ` QAudioSource ` et définir la taille de son tampon.

    formatAudio.setSampleFormat(QAudioFormat::UInt8);

    m_audioSource = new QAudioSource(deviceInfo, formatAudio);

Il est maintenant temps d'associer nos données au graphique. Pour ce faire, nous avons créé une classe XYSeriesIODevice. Reportez-vous à XYSeriesIODevice pour connaître son implémentation.

    m_audioSource->setBufferSize(200);

    m_device = new XYSeriesIODevice(m_series, this);
    m_device->open(QIODevice::WriteOnly);

XYSeriesIODevice

Implémentée dans ` xyseriesiodevice.cpp`, la classe `XYSeriesIODevice` se charge de l’échantillonnage du signal. La fonction ` writeData `, avec une résolution fixe de 4, définit la taille de ` QList ` m_buffer en fonction du nombre d’échantillons, puis la remplit avec des objets `QPointF` dont la valeur x est incrémentée et la valeur y est définie à 0.

{
    static const int resolution = 4;

    if (m_buffer.isEmpty()) {
        m_buffer.reserve(sampleCount);
        for (int i = 0; i < sampleCount; ++i)
            m_buffer.append(QPointF(i, 0));
    }

    int start = 0;

Nous procédons ensuite à l'échantillonnage.

    const int availableSamples = int(maxSize) / resolution;
    if (availableSamples < sampleCount) {
        start = sampleCount - availableSamples;
        for (int s = 0; s < start; ++s)
            m_buffer[s].setY(m_buffer.at(s + availableSamples).y());
    }

    for (int s = start; s < sampleCount; ++s, data += resolution)
        m_buffer[s].setY(qreal(uchar(*data) -128) / qreal(128));

    m_series->replace(m_buffer);
    return (sampleCount - start) * resolution;

Exemple de projet sur code.qt.io