Discussion :

[Firenerevar30]

Bonjour à tous!
Je me tourne vers vous car j'ai un problème avec l'utilisation de la librairie opus. mon petit programme doit lire les donnée audio (LIB SFML), l'encodé (LIB OPUS), decodé (LIB OPUS) et de lire le flux sonore.

mon objectif final et normalement d'envoyer le flux audio encodé sur le réseau, et de le lire sur un autre ordi.

Avant d'utilisé la librairie opus tout fonctionné très bien! mais depuis que j'utilise cette librairie la musique en sortie et très hachuré, rapide, et il manque des données audio. Cela va faire trois jours que je suis sur ce bug et malgré la documentation d'opus je ne parvient toujours pas à réglé mon problème.
je pense avant tout que le problème viens que j'utilise mal l'encodeur et le décodeur audio.
je tiens aussi à préciser que je ne suis pas tres doué dans le domaine de l'audio
je vous donne mon code en espérant que cela peu vous aidée.

le main:

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
int main(void)
{
// OPUS
    int error;
    OpusEncoder *encoder=NULL;
//INIT INPUTSOUNDFILE
    sf::InputSoundFile file;
    if (!file.openFromFile("/home/ledoux/Qt_creator/projet/C++/progets/proj_mentora_terminal/projet_final_mentora/KariSigurdssonTwistofFate.wav"))
    {
        std::cout<<"erreur"<<std::endl;
    }
 
        int taille_absolu(2880*2*sizeof(opus_int16));
 
    sf::Uint64 boucle;
 
//CREATION DU FLUX AUDIO
    audiostream stream;
    stream.initialization(file.getChannelCount(),file.getSampleRate());
//INIT OPUS
    encoder=opus_encoder_create(48000,file.getChannelCount(),OPUS_APPLICATION_AUDIO,&error);
 
 
    do
    {
//RECUPERATION D'UN LOTS D'ECHANTILLIONS
        sf::Int16 lots_echantillions[taille_absolu];
        boucle = file.read(lots_echantillions, taille_absolu);
 
//ENCODAGE
        std::vector<unsigned char>lots_echantillion_encoder(taille_absolu);
        opus_int32 sortie_audio_encoder(0);
        sortie_audio_encoder = opus_encode(encoder,lots_echantillions,2880,&lots_echantillion_encoder[0],taille_absolu);
        lots_echantillion_encoder.resize(sortie_audio_encoder);
 
//ENVOI DES DONNÉES ENCODÉE
        stream.load(lots_echantillion_encoder);
 
 
//LECTURE AUDIO
        if(stream.getStatus()!= audiostream::Playing)
        {
            stream.play();
        }
 
    }        while (boucle > 0);
 
 
 
    while(stream.getStatus() == audiostream::Playing)
    {
        sf::sleep(sf::seconds(0.1f));
    }
}

audiostream.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
31
32
33
34
35
36
37
38
 
#ifndef SOUNDSTREAM_H
#define SOUNDSTREAM_H
//#include<SFML/Audio.hpp>
//#include<SFML/Network.hpp>
 
 
 
#include<iostream>
#include<vector>
#include<queue>
 
#include"../define_serveur_client.h"
 
 
class audiostream : public sf::SoundStream
{
public:
    audiostream();
    void load(std::vector<unsigned char> tableau);
    void initialization(unsigned int canaux, unsigned int taux_echantillonnage);
    void lecture_audio();
protected:
 
private:
    virtual bool onGetData(Chunk &data);
 
    virtual void onSeek(sf::Time timeoffset);
 
    std::queue<std::vector< sf::Int16>>m_echantillon;
    std::size_t m_echantillon_en_cours;
    bool m_initialiser;
    int m_erreur;
    OpusDecoder* m_decodeur;
 
};
 
#endif//SOUNDSTREAM_H

audiostream.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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
 
 
#include "audiostream.h"
audiostream::audiostream()
{
//INIT OPUS
    m_decodeur=opus_decoder_create(48000,2,&m_erreur);
 
}
 
 
    void audiostream::load(std::vector<unsigned char> tableau)
    {
 
        int variable_abs(2880*2*sizeof(opus_int16)),taille_decode(0);
        std::vector<sf::Int16>echantillions(variable_abs);
//DECODAGE DONNÉE
        taille_decode=opus_decode(m_decodeur,&tableau[0],tableau.size(),&echantillions[0],variable_abs,0);
        echantillions.resize(taille_decode);
//RAJOUT DONNÉE EN ATTENTE DE LECTURE
        m_echantillon.push(echantillions);
 
    }
 
bool audiostream::onGetData(Chunk &data)
{
 
// AVANT LECTURE DES DONNÉE AUDIO AVOIR AU MOINS UNE RÉSERVE DE DEUX CHUNK
         if(m_echantillon.size()>=2)
         {
 
             m_echantillon.pop();
             data.samples = &m_echantillon.front()[0];
             data.sampleCount = m_echantillon.front().size();
             return true;
 
         }
         return false;
}
 
 
void audiostream::onSeek(sf::Time timeoffset)
{
    //     m_echantillon_en_cours = static_cast<std::size_t>(timeoffset.asSeconds()+getSampleRate()*getChannelCount());
}
 
void audiostream::lecture_audio()
{
 
    play();
    std::cout<<"lecture "<<std::endl;
    while(this->getStatus() == audiostream::Playing)
    {
        sf::sleep(sf::seconds(0.1f));
    }
}
 
void audiostream::initialization(unsigned int canaux, unsigned int taux_echantillonnage)
{
    initialize(canaux,taux_echantillonnage);
    m_initialiser = true;
}

petite précision la musique que je joue à une fréquence échantillonnage de 44100 hz mais opus demande au maximun 48000 hz
si vous pouviez me donnée au moins une direction ou je puisse cherché ou des explications à son fonctionnement.
Merci d'avance pour vos réponse!!

[Firenerevar30]

problème résolu!
Cela venez tu tableau d'échantillonnage décodé

Code :

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

1
2
3
4
5
6
7
 
        int taille_decode;
        std::vector<sf::Int16>echantillions(TAILLE_ABSOLU);
        taille_decode=opus_decode(m_decodeur,&tableau[0],tableau.size(),&echantillions[0],VARIABLE_ELEMENTAIRE,0);
        LOG("TAILLE_DECODE",taille_decode);
        echantillions.resize(taille_decode*CANAUX); <---------------------
        m_echantillon.push(echantillions);

il faut multiplié la taille tu tableau par le nombre de canaux!