Discussion :

[olivier.a]

Bonjour,

Je suis entrain de faire un lecteur/éditeur audio pour mon projet de fin d'année.
Pour pouvoir intérargir avec l'interface graphique tout en lisant un son, j'ai ajouté un thread en suivant la méthode décrite ici et grâce à l'aide de yan ici. Mon thread fonctionne bien dans le sens où je peux accéder à l'interface graphique pendant la lecture mais maintenant mon son est hachuré.

Yan m'a envoyé vers ce lien, mais c'est pour les sons ogg. J'ai regardé si je pouvais pas trouver quelque chose pour les sons wav mais sans succès.

PlayerThread.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
#ifndef PLAYERTHREAD_H
#define PLAYERTHREAD_H
 
#include <QThread>
#include <al.h>
#include <alc.h>
#include "PlayerAL.h"
 
class PlayerThread : public QThread{
    Q_OBJECT
 
private :
    PlayerAL player;
protected:
    void run();
public:
    void loadBuffer(const std::string &);
    void changeVolume(ALfloat);
    void changeBalance(int);
    void setCurrentBuffer(int);
    bool isPlaying();
signals:
    void previousBuffer();
    void play();
    void pause();
    void stop();
    void nextBuffer();
};
#endif // PLAYERTHREAD_H

PlayerThread.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
#include "PlayerThread.h"
using namespace std;
 
void PlayerThread::run(){
    connect(this,SIGNAL(previousBuffer()),&player,SLOT(previousBuffer()));
    connect(this,SIGNAL(play()),&player,SLOT(play()));
    connect(this,SIGNAL(pause()),&player,SLOT(pause()));
    connect(this,SIGNAL(stop()),&player,SLOT(stop()));
    connect(this,SIGNAL(nextBuffer()),&player,SLOT(nextBuffer()));
    exec();
}
 
void PlayerThread::loadBuffer(const string & path){
    player.loadBuffer(path);
}
 
void PlayerThread::changeVolume(ALfloat value){
    player.changeVolume(value);
}
 
void PlayerThread::changeBalance(int value){
    player.changeBalance(value);
}
 
void PlayerThread::setCurrentBuffer(int index){
    player.setCurrentBuffer(index);
}
 
bool PlayerThread::isPlaying(){
    return player.isPlaying();
}

Player.cpp (partie de la lecture)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
void PlayerAL::play(){
    if(!buffers.empty()){
        alSourcei(source,AL_BUFFER,buffers[currentBuffer]);
        alSourcePlay(source);
        playing=true;
        alSourceUnqueueBuffers(source,1,&buffers[currentBuffer]);
        playing=false;
    }
}

Ici j'ai une liste de buffers qui représente les sons ouverts, je lie le buffer courant (celui sélectionné par l'utilisateur) à la source puis je le lis et je le retire de la source pour éviter d'avoir une playlist.

Merci d'avance
Olivier

[olivier.a]

pas d'idées ?

[super_neon]

Salut Olivier,

Pour lire ton fichier wav en streaming de la même manière que le fichier ogg,
il suffit de placer ta tête de lecture au début des donnés du fichier son et de
streamer son contenu.

exemple de streaming:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
 // on remplit le buffer.
 int nRead = fread(buffers[currentBuffer], 1, m_nBufferSize, pFile);
 
 // mise à jours de la position.
 // m_nSize = taille du fichier
 m_nPosition += nRead;
 if(m_nPosition >= m_nSize)
 {
    m_nPosition = m_nOffset; // On zappe l'entête
    fseek(pFile, 0,  SEEK_SET);
 }

C'est possible que le son soit hachuré si la mise à jours des buffers n'est pas suffisamment rapide.

Par contre je ne comprend pas, il semble que ton buffer contient l'ensemble des donnés du fichier son ? Dans ce cas là, il n'y a pas de streaming puisque tout est en ram.

Tu trouveras la description de l'entête ici:
https://ccrma.stanford.edu/courses/4...ts/WaveFormat/


En espérant que cela réponde a ta question

[olivier.a]

Bonjour,

J'étais un peu perdu avec l'histoire de streaming, parce que je n'avais pas l'impression que mon programme faisait ça. Maintenant je comprends un peu mieux comment ça marche. On stocke tout dans la ram et on envoie petits bouts par petits bouts la musique à la carte son.

Ca faisait deux semaines que j'étais bloqué sur ce problème et j'en ai eu un peu marre alors je suis passé à autre chose. J'ai retravaillé sur mon code pour afficher les graphiques du son et depuis j'ai plus de son hachuré.

Voici le code que j'ai changé :

MainWindow.cpp (avant)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
void MainWindow::openFiles(){
    //Open the filedialog in "user/documents/music" folder
    QStringList chosenFiles = QFileDialog::getOpenFileNames(this,"Open music file",QDesktopServices::storageLocation(QDesktopServices::MusicLocation));
    if(!chosenFiles.isEmpty()){
        foreach(QString string, chosenFiles){
            File fi(string.toStdString());
            files.append(fi);
            addFileInTree(fi);
            thread.loadBuffer(fi.getPath());
            QwtPlot* g = Graph::waveForm(fi);
            if(g)
                ui->graphLayout->addWidget(g);
        }
    }
    else
        printf("liste vide");
}

MainWindow.cpp (après)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void MainWindow::openFiles(){
    //Open the filedialog in "user/documents/music" folder
    QStringList chosenFiles = QFileDialog::getOpenFileNames(this,"Open music file",QDesktopServices::storageLocation(QDesktopServices::MusicLocation));
    if(!chosenFiles.isEmpty()){
        foreach(QString string, chosenFiles){
            File fi(string.toStdString());
            files.append(fi);
            addFileInTree(fi);
            thread.loadBuffer(fi.getPath());
            graphs.append(Graph(fi));
        }
    }
}

Maintenant je stocke mes graph dans une liste et quand l'utilisateur change de musique, j'actualise le layout. Et avant, "Graph" était un namespace et je l'ai modifier pour faire une classe.
Sur ce soup là, j'ai l'impression que c'est de la magie.

[super_neon]

Salut Olivier,

Le principe du streaming c'est de ne pas prendre trop de place en RAM et donc de lire petit bout par petit bout un flux (ici un fichier) et de le lire.

Si tu envois un buffer contenant l'ensemble de fichier audio a OpenAL, tu ne fais pas de streaming.

Pour ce qui est des changements que tu as fait, j'en ai aucune idée

Dans tout les cas si ton programme fonctionne comme tu veux c'est l'essentiel. Après si tu souhaites développer le streaming n'hésite pas a pauser des questions.