Signial Audio / Spectrogramme Java

Version imprimable

10/06/2015, 14h36
Badshade23

Signial Audio / Spectrogramme Java

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 :).
10/06/2015, 20h00
joel.drigo

Salut

:arrow: musicg
11/06/2015, 10h36
Badshade23

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 :weird:. Donc par la suite je n'ai pas cherché beaucoup plus loin ayant peur de perdre mon temps. J’ai du mal chercher :oops: je vais regarder de nouveau de ce coter. Si tu as des exemple je suis preneur :D.
Merci encore
11/06/2015, 11h21
wax78

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)
11/06/2015, 15h09
Badshade23

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 ... ^^
11/06/2015, 15h25
joel.drigo

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)
15/06/2015, 11h44
Badshade23

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 :D.
15/06/2015, 15h19
Badshade23

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)

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

Code:

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);

15/06/2015, 15h54
Badshade23

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 :mrgreen:

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 ...)

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:

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:

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.

15/06/2015, 17h18
Badshade23

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 :oops:. 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 ?? :roll:

Citation:

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:

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:

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.

17/06/2015, 13h14
Badshade23

Merci beaucoup pour la réponse,
Je vais essayer de faire ce que tu as dit et je tiendrai au courant le poste :D
18/06/2015, 15h38
Badshade23

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 :weird: . Personnellement je l'ai mis dans un thread mais le handleEvent se déclenche uniquement 8 fois :calim2: une idée ??
18/06/2015, 16h18
wax78

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

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

Code:

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 :mouarf: ) :

Code:

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");
   }
 
 
}

Mon thread s’initialise et ce lance suite a l'appuie d'un bouton tout simplement :).

22/06/2015, 09h52
Badshade23

Personne n'a d'idée ??
08/07/2015, 17h14
Badshade23

Suite à quelque changement j'ai complétement changer de lib. Si ça intéresse quelqu'un : http://stackoverflow.com/questions/3...-my-sound-card