Échantillons audio et niveau sonore

L'implémentation de cet exemple est basée sur les Widgets. Pour plus d'informations à ce sujet, reportez-vous à la section Premiers pas dans la programmation avec Qt Widgets. Les sections suivantes expliquent comment utiliser l'API Qt Charts pour afficher des données dynamiques sur un graphique d'échantillons en fonction du niveau sonore. Pour plus d'informations sur l'échantillonnage, voir Échantillonnage_(traitement_du_signal).

Exécution de l'exemple

Pour exécuter l'exemple à partir de Qt Creatorouvrez le mode Welcome et sélectionnez l'exemple à partir de Examples. Pour plus d'informations, voir Qt Creator: Tutoriel : Construire et exécuter.

Récupération des données audio

Grâce à l'inclusion du module Qt Multimedia dans main.cpp, nous créons un nouveau QAudioDevice qui représente le périphérique audio par défaut de la plateforme cible. Nous vérifions également que nous disposons d'un périphérique d'entrée audio et informons l'utilisateur s'il n'y a pas de périphérique d'entrée audio 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 à l'aide de l'argument de son constructeur w. Ensuite, w.show() est appelé pour afficher le widget.

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

Mise en place du graphique

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

Dans widget.cpp, le constructeur Widget réimplémenté fait le gros du travail en ce qui concerne 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 "Échantillons"

Nous définissons la plage min-max de l'axe des x de 0 à XYSeriesIODevice::sampleCount. (Déclaré dans xyseriesiodevice.h en tant que 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 ordonnées "Niveau audio"

Nous créons le site QValueAxis axisY , définissons sa plage et son titre.

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

Fixer les axes et définir le titre du graphique

Nous fixons les axes, masquons la légende et définissons le titre du graphique de manière à inclure 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 site QVBoxLayout mainLayout et ajoutons un 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 à QLineSeries m_series . Comme précédemment, cela repose sur le module Qt Multimedia.

Tout d'abord, nous transmettons deviceInfo à un constructeur QAudioInput.

    mainLayout->addWidget(chartView);

    m_audioInput = new QAudioInput(deviceInfo, this);

    QAudioFormat formatAudio;

Nous configurons ensuite notre QAudioFormat formatAudio , son nombre de canaux, sa fréquence d'échantillonnage et son format d'échantillonnage.

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

Nous pouvons maintenant 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'attacher nos données au graphique. Pour ce faire, nous avons créé une classe XYSeriesIODevice. Voir XYSeriesIODevice pour savoir comment elle est implémentée.

    m_audioSource->setBufferSize(200);

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

XYSeriesIODevice

Implémenté dans xyseriesiodevice.cpp, 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, et la remplit de QPointF avec une valeur x incrémentielle et une valeur y fixée à 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 à un é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 @ code.qt.io