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:
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
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.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 #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
petite précision la musique que je joue à une fréquence échantillonnage de 44100 hz mais opus demande au maximun 48000 hz
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; }
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!!
Partager