Signial Audio / Spectrogramme Java

**Badshade23** · 10/06/2015, 14h36

Bonjours tout le monde,

J'aimerai connaitre votre avis. Je suis à la cherche d'une librairie ou d'une Api qui permettrai de crée un signal audio / spectre. A l'heure actuelle j'ai mon flux octets qui arrive en temps réel donc j'ai mes données, il me manque plus qu'à les afficher. Après de nombreuses recherches je me suis arrêter sur JFreeChart et j'ai réussi a créé un graph dynamique de type "TimeSeriesCollection (mes valeur en ordonnées et le temps réel en abscisse) mais ce traitement prend trop de puissance du CPU, je pense que cette librairie n'est pas faite pour ce genre de traitement. Donc je voudrai savoir si vous connaissez d'autre lib APi qui serait plus performante à ce sujet...

Je vous remercie d'avance

.

**joel.drigo** · 10/06/2015, 20h00

Salut

musicg

**Badshade23** · 11/06/2015, 10h36

Bonjours,
Merci pour la réponse, j'avais déjà regardé de ce coter en téléchargent les sources : musicg-1.4.2.0.jar.
J'ai ensuite copié les dossiers src et graphic dans un projet test pour voir ce que ça donne et les quelques main que j'ai trouvé me lance des commandes en console

. Donc par la suite je n'ai pas cherché beaucoup plus loin ayant peur de perdre mon temps. J’ai du mal chercher

je vais regarder de nouveau de ce coter. Si tu as des exemple je suis preneur

.
Merci encore

**wax78** · 11/06/2015, 11h21

MusicG, je pense, n'est pas fait pour faire de l'affichage temps réel.

Ce qu'on peut voir dans les exemple ce sont des rendus du signal dans un fichier jpg (ou autres formats)

**Badshade23** · 11/06/2015, 15h09

Oui c'est ce que j'ai remarqué j'ai deux jpeg sur les spectrogrammes de mon son et deux "waveform" qui représente le signal audio. Ceci ne répond donc pas à ma recherche

. J'ai trouvé aussi "jmathstudio - Java image / signal" ou "TarsosDSP" mais je n'ai pas tout comprit de leur utilisation encore ... Donc je suis toujours preneur si quelqu'un a une idée, exemple ... ^^

**joel.drigo** · 11/06/2015, 15h25

Si on a une API qui peut générer une image pour un signal, on doit pouvoir assez facilement générer plusieurs images à intervalle régulier et faire du temps réel, sauf temps de génération de l'image trop lent.
Cela dit TarsoDSP m'a l'air très bien : je viens de regarder et c'est simplissime. Tu télécharges le zip et tu le dezippes (Voir "Quicky Getting started.../[...]release of TarsosDSP[...]). Tu te crées un projet dans Eclipse (ou l'IDE que tu veux), tu copies les jar (TarsoDSP-2.2.jar, TarsoDSP-2.2-bin.jar, Spectrogram-2.2.jar et/ou Oscilloscop-2.2.jar) dans ton projet, et tu les montes (Add to build path). Tu ouvres la classe be.tarsos.dsp.example.Spectrogram et tu voies un magnifique exemple Swing de Spectrogramme (pareil pour be.tarsos.dsp.example.OscilloscopeExample, pour l'oscillo)

**Badshade23** · 15/06/2015, 11h44

Oui TarsosDSP est pas mal du tout, j'ai regardé tous leurs exemples ils ont fait du beau boulot. Je vais voir comment réutiliser ce petit bijoux

.

**Badshade23** · 15/06/2015, 15h19

Je rencontre un probleme, après avoir examiner le code de l'oscilloscope je me suis rendu compte qu'ils affichaient le graphe en ouvrant un line (TargetDataLine) sur la carte audio choisi. Mon probleme c'est que moi j'ai uniquement un tableau d'octet qui contient mon son (tableau qui se met a jour au fur et a mesure)

**joel.drigo** · 15/06/2015, 15h32

Tu dois pouvoir créer la TargetDataLine à partir de ton tableau d'octets comme ça :

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
byte[] audioData = ...;
InputStream byteArrayInputStream = new ByteArrayInputStream(audioData);
 
// exemple de format (remplir les trous ) :
float sampleRate = ...; //8000,11025,16000,22050,44100
int sampleSizeInBits = ...; //8,16
int channels = 1; //1,2
boolean signed = true; //true,false
boolean bigEndian = false; //true,false
AudioFormat audioFormat = new AudioFormat(sampleRate, sampleSizeInBits, channels, signed, bigEndian);
 
AudioInputStream audioInputStream = new AudioInputStream(byteArrayInputStream, audioFormat, audioData.length / audioFormat.getFrameSize());
DataLine.Info dataLineInfo = new DataLine.Info(TargetDataLine.class, audioFormat);
 
TargetDataLine targetDataLine = (TargetDataLine) AudioSystem.getLine(dataLineInfo);

**Badshade23** · 15/06/2015, 15h54

Merci pour la réponse mais je sais comment crée une line avec un tableau d'octet. J'ai du mal m'exprimer

mon problème c'est que ce tableau évolue tout le temps (il a 1(s) de son qu'il écrase au fur et à mesure pour ne pas surcharger ma mémoire). Donc je ne peux pas crée de line car elle sera vite obsolète ou il faudrait que j'en crée une toute les secondes ce qui a mon avis fera trop de traitement.
Je sais pas si je réussi a bien m'exprimer

PS: Voici pourquoi je ne peux pas utiliser ma line. Sur ma carte son j'ai deux émetteurs (IPod,...) donc je récupère mes données sous forme de tableau d'octets seconde après seconde et je sépare les canaux pour récupérer qu'un émetteur après l'autre. Le truc c'est que ma line n'est plus utilisable après car je voudrai le spectre d'un seul émetteur et non les deux. J'ai donc plus qu’un tableau par émetteur qui contient une seconde de son (jusqu'à ce que je l'écrive sur le disque après je prends l’autre seconde ...)

**joel.drigo** · 15/06/2015, 16h12

Dans ce cas, au lieu d'utiliser un ByteArrayInputStream, implémente ton propre InputStream (le principe est que l'appel de int read() doit toujours retourner le prochain octet, quelque soit la façon dont sont produits les octets.

Je ne sais pas exactement comment tu as fait ton tableau (un buffer tournant ?)

Mais, en gros, le principe est le même dans tous les cas ; tu fais :

Code pseudocode :

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

1
2
3
4
5
6
7
8
9
int read() {
    si aucun octet écrit dans le tableau, ou tous les octets déjà lus
       // attendre qu'on y écrive quelque chose
       synchronized( tableau ) { // simplifié, mais voir si un Lock plus efficace
         tableau.wait();
       }
    fin si
    return prochain octet non encore lu
}

Et pour le remplir :

Code pseudocode :

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

1
2
3
4
5
 
synchronized( tableau ) {
   écrire de nouvelles données dans le tableau
   tableau.notify() // prévenir qu'on a écrit des trucs dans le tableau
}

Exemple plus complet d'un buffer tournant bloquant : ici.

**Badshade23** · 15/06/2015, 17h18

Je n'utilise pas de buffer tournant j'ai juste crée deux tableaux de byte (voix gauche, voix droite) qui vaut une seconde de temps (je calcule la taille via le format audio 16bit 44kHz…)
Je récupère donc c'est données grâce à un thread qui contient mes lines ouvertes sur une ou plusieurs cartes audio après ce thread notifie mes divers classes (observable, observer) quand le tableau a ses 1s de son et mes a jours les variables ….

Pour ta solution je n'ai pas tout comprit

. Tu me recommande donc de faire un AudioInputStream avec en paramètre un InputStream que je redéfinie , mon format audio, et quelle taille ?)
Et pour l'inputStream je créé mon propre stream en redéfinissent la méthode read et tout ??

**joel.drigo** · 15/06/2015, 17h41

Envoyé par Badshade23

Tu me recommande donc de faire un AudioInputStream avec en paramètre un InputStream que je redéfinie

Oui. Dans le cas de l'exemple que je t'ai donné, on part d'un tableau où il y a tout le son, de mettons 3 secondes de durée. Chaque octet est une donnée : l'inputStream sert chacun de ces octets, les un après les autres, à chaque appel de read. Qu'ils viennent d'un tableau qui représentent 3 secondes de son, ou 3 tableaux successifs qui représentent chacun 1 seconde de son.

Dans ton cas, tu parles d'avoir un tableau qui contient une seconde de son, qui se remplit toutes les secondes. Donc c'est le cas standard (on lit un octet, on incrément la position dans le tableau (jusqu'au bout du tableau), mais simplement, la position est réinitialisée toutes les secondes à 0, et les données dans le tableau change (ou le tableau change). C'est encore plus simple que pour le buffer tournant, au glitch près dirons nous (qu'on va considérer négligeable pour commencer). Donc une seconde de son ça prend length octets (en fonction de la fréquence) :

lire (dans l'inputStream)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int read() {
 
   synchronized( array ) {
   if ( cursor<length ) {
        return array[cursor++];
   }
   else {
        attendre ( le array.wait() de l'autre exemple)
   }
   }
 
 
}

écrire (mettre une nouvelle seconde de son dans le tableau) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
write( data ) {
 
   synchronized( array ) {
 
        remplacer array par data (que ça soit par copie de l'un vers l'autre, ou remplacement de la référence : juste dans ce dernier cas, attention à la synchronisation, elle ne peut plus se faire sur la référence de tableau - il faut changer non seulement le curseur, mais aussi le tableau, et le wait/notify ne pourrait plus fonctionner - il suffit de prendre une référence d'objet quelconque), 
        cursor = 0; // on recommence au début : ça va causer potentiellement un glitch (parce que l'ensemble de la seconde de son précédent n'aura pas forcément été complètement lue)
 
        array.notify();
 
   }
 
}

Le glitch, c'est juste un défaut en fin de seconde, plus ou moins visible, en fonction du retard du composant de visualisation. Au moins ça resynchronise celui-ci avec le "temps réel". Tu verras bien de visu si c'est gênant ou pas.

**Badshade23** · 17/06/2015, 13h14

Merci beaucoup pour la réponse,
Je vais essayer de faire ce que tu as dit et je tiendrai au courant le poste

**Badshade23** · 18/06/2015, 15h38

J'ai réussi à faire mon propre InputStream en suivant tes conseilles et j'ai commencé à décortiquer le code de l'oscillo mais je ne comprends pas totalement le "OscilloscopeEventHandler" , je ne vois pas quand il se déclenche

. Personnellement je l'ai mis dans un thread mais le handleEvent se déclenche uniquement 8 fois

une idée ??

**wax78** · 18/06/2015, 16h18

Sans voir de code, on peut deviner tout et n'importe quoi

**Badshade23** · 18/06/2015, 16h50

Exacte ^^ , voici mon code enfin un partie. La class InputStreamAudio où je redéfinie mon InputStream :

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
package application.metier;
 
import java.io.IOException;
import java.io.InputStream;
 
public class InputStreamAudio extends InputStream {
 
   private byte[] tabCanalDroit  = null;
   private byte[] tabCanalGauche = null; ;
 
   private int    cursor         = 0;
   private String canal          = null;
 
   /**
    * 
    */
   public void init(int tailleTab) {
      tabCanalDroit = new byte[tailleTab];
      tabCanalGauche = new byte[tailleTab];
   }
 
   @Override
   public int read() throws IOException {
      // Si il faut afficher le canal gauche
      if (canal.equals("GAUCHE")) {
         synchronized (tabCanalGauche) {
            if (cursor < tabCanalGauche.length) {
               return tabCanalGauche[cursor++];
            } else {
               try {
                  tabCanalGauche.wait();
               } catch (InterruptedException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
               }
               // attendre (le array.wait() de l'autre exemple)
            }
         }
         return 0;
         // sinon on affiche le canal droit
      } else {
         synchronized (tabCanalDroit) {
            if (cursor < tabCanalDroit.length) {
               return tabCanalDroit[cursor++];
            } else {
                try {
               //System.out.println("passssssssssseeeeeeeeeeeeeeee pppppppppppppllllllllllllluuuuuuuuuuuuuuussssssssssssssss");
               tabCanalDroit.wait();
               } catch (InterruptedException e) {
                 //TODO Auto-generated catch block
                e.printStackTrace();
                }
               // attendre (le array.wait() de l'autre exemple)
            }
         }
         return 0;
      }
 
   }
 
   public void write(byte[] pTabCanalDroit, byte[] pTabCanalGauche) {
      synchronized (tabCanalDroit) {// synchronise ici le tab est utiliser ou non
         for (int i = 0; i < pTabCanalDroit.length; i++) {
            tabCanalDroit[i] = pTabCanalDroit[i];
         }
         cursor = 0;
         tabCanalDroit.notify();
      }
 
      synchronized (tabCanalGauche) {// synchronise ici le tab est utiliser ou non
         //tabCanalGauche = pTabCanalGauche;
         for (int i = 0; i < tabCanalGauche.length; i++) {
            tabCanalGauche[i] = pTabCanalGauche[i];
         }
         cursor = 0;
         tabCanalGauche.notify();
      }
   }
 
   /**
    * Setter.
    * 
    * @param pCanal canal
    */
   public void setCanal(String pCanal) {
      this.canal = pCanal;
   }
 
   /**
    * Getter.
    * 
    * @return tabCanalDroit
    */
   public byte[] getTabCanalDroit() {
      return tabCanalDroit;
   }
 
}

et mon petit thread (ces deux class sont en cours de développement donc les sysout ... sont normale

) :

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
package application.metier;
 
import javax.sound.sampled.AudioInputStream;
import be.tarsos.dsp.AudioDispatcher;
import be.tarsos.dsp.AudioEvent;
import be.tarsos.dsp.Oscilloscope;
import be.tarsos.dsp.Oscilloscope.OscilloscopeEventHandler;
import be.tarsos.dsp.io.jvm.JVMAudioInputStream;
import application.donnees.Carte;
import application.ihm.graph.GraphPanel;
 
public class ThreadGraph extends Thread implements OscilloscopeEventHandler {
 
   private Carte carte = null;
   private GraphPanel graphPanel = null;
   private int bufferSize = 2048;
   private int overlap = 0;
   /**
    * Constructeur.
    * @param graphPanel 
    * @param carte 
    */
   public ThreadGraph(Carte pCarte, GraphPanel pGraphPanel) {
      this.carte = pCarte;
      this.graphPanel = pGraphPanel;
 
   }
 
   @Override
   public void run() {
 
      super.run();
      AudioInputStream stream = new AudioInputStream(carte.getInputStreamAudio(), carte.getAudioFormat(), carte.getInputStreamAudio().getTabCanalDroit().length);
      JVMAudioInputStream audioStream = new JVMAudioInputStream(stream);
      AudioDispatcher dispatcher= new AudioDispatcher(audioStream, bufferSize,overlap);
      dispatcher.addAudioProcessor(new Oscilloscope(this));
      new Thread(dispatcher,"Audio dispatching").start();
   }
 
   @Override
   public void handleEvent(float[] data, AudioEvent event) {
      graphPanel.paint(data,event);
      graphPanel.repaint();
      System.out.println("passssssssssssssssssssssssseeeeeeeeeeeeeeee");
   }
 
 
}