Échantillon de son codé par des octets

Bonjour,

je vais commencer par les très traditionnelles excuses pour le cas où la réponse à ma question aurait échappé à mes (longues) recherches, et dans le cas où mon message serait mal placé.

Ceci fait, venons-en au problème en lui même.

Dans le cadre d'un projet étudiant, je souhaite réaliser un programme java qui travaillera en temps réel sur des données de type son. Plus précisément, je veux recevoir une musique via le micro et, entre autres, en détecter en temps réel les notes (fréquences des notes, durée).

Je ne viens bien évidemment pas demander qu'on me fasse le programme, mais je bloque sur un gros détail :

Sachant que je ne souhaite à aucun moment enregistrer le son sous la forme d'un fichier (sauf éventuellement à la toute fin), il me faut travailler directement dessus. Il y a plusieurs algorithmes à implémenter - détection d'enveloppe, transformées de Fourier et compagnie.

Ces algorithmes prennent idéalement en entrée un tableau de type temps-fréquence.

Voici donc le problème qui me préoccupe :

Je créé une ligne (TargetDataLine, du package javax.sound.sampled) qui stocke les échantillons de son envoyés par la carte son. Pour pouvoir travailler sur ces échantillons, j'utilise la fonction read pour transférer ces données dans un tableau.

Qu'ai je dans mon tableau ? Des octets.
Mais je n'ai aucune idée de ce que représentent concrètement ces octets, et donc aucune idée de ce que je dois faire pour les manipuler. Je n'ai rien trouvé sur google...

J'aimerais donc savoir comment sont "codés" ces octets, et comment il m'est possible à partir d'eux de récupérer les informations sur l'échantillon du son - disons l'amplitude et la fréquence du son (le temps étant toujours le même, le son étant échantillonné de façon régulière à des intervalles que j'ai défini).

Merci d'avance à toute personne qui pourra me débloquer, parce que là, je ne vois vraiment pas trop quoi faire.

Salut, je ne suis pas vraiment compétent en traitement du son mais as-tu regardé ces 2 articles qui parlent justement de la transformation de Fourier en java?
Fun with Java, Understanding the Fast Fourier Transform (FFT) Algorithm
Spectrum Analysis using Java, Sampling Frequency, Folding Frequency, and the FFT Algorithm
La classe ForwardRealToComplexFFT01 du 2è article semble être celle qui implémente la transformation.

Cela demande une certaine habitude (que je n'ai pas) des formats de représentation sonore.

Mais le format des octets que tu lis devrait être spécifié par l'objet AudioFormat que tu as passé à la méthode open().

L'implémentation de la transformée de Fourier en java n'est pas mon problème, mais merci des liens, je les visiterai à tout hasard.

en effet, j'ai omis de spécifier le format des données que je recevais :

format pcm, deux canaux, 16 bits, 44100 Hz, ordre des octets BigEndian. J'ai vu à peu près tous cess points dans des cours sur le traitement du son en java - je sais donc sous quel format les octets sont "recueillis", mais je ne sais toujours pas à quoi ils correspondent précisément - moi, je n'y vois qu'une suite de 0 et de 1 ; j'en tirerais volontier une amplitude et/ou une fréquence, mais comment faire ?

Tes 0 et tes 1 sont des paquets de 16. Car tu es en 16bits et en 44100Hz.
Tu vas avoir 44100 valeurs de 16bits par seconde d'enregistrement.
Tu places les valeurs (donc de 0 à 65535) sur une courbe que tu devras analyser pour en tirer la fréquence du son.

Oh, voilà qui m'éclaire déjà un peu, merci beaucoup.

Je veux bien placer les valeurs sur la courbe et l'analyser ensuite, mais c'est une courbe de quoi en fonction de quoi ? Plus précisément, les nombres stockés dans les 16 bits sont en quelle unité ? Est-ce une courbe d'amplitude ?

EDIT : bon, c'est clairement "quelque chose" en fonction du temps, mais l'inconnu à mes yeux réside dans l'unité du nombre stocké. J'imagine très bien une courbe de la forme (t, s(t) ) ou s est "l'onde" cherchée, mais je n'ai pas l'unité en tête.

Après, à ce stade, je ne suis plus sur le bon forum je pense ^^

Sans être expert, je pense pas qu'il y ait vraiment d'unité bien définie a ce stade (étant donné les drivers et le matériel audio doivent gérer leur propre bazar pour le transformer en un signal physique selon tout un tas de contraintes, y compris le volume des enceintes et autres). Dis toi juste qu'une grosse amplitude de valeurs fera un son plus fort.
Par contre, il faut pas oublier que le signal ne sera pas entre 0 et 65K, mais bien entre -37K et +37K donc je conseille de passer tes valeurs en floats, de normaliser (diviser par 65536) et soustraire 0.5f.

Oui c'est un signal d'une résolution de 16bits, il n'y a pas encore de décibel à ce stade.

Citation:

---

Envoyé par Lyndor

Dans le cadre d'un projet étudiant, je souhaite réaliser un programme java qui travaillera en temps réel sur des données de type son. Plus précisément, je veux recevoir une musique via le micro et, entre autres, en détecter en temps réel les notes (fréquences des notes, durée).

---

Ceci pourrait peut etre t'interesser niveau conversion de données sonores ... (float->byte->float conversion etc) ICI

Sinon c'est intéressant, j'ai deja fait un truc similaire il y'a qlq temps...

Tu comptes faire un algorithme qui gère la polyphonie ou une seule note a la fois ?

Merci beaucoup pour vos réponses, je vais essayer de me débrouiller avec ça, ça devrait bien se passer désormais.

@wax78 : En fait, il y a deux échéances pour notre programme JAVA - la première arrive d'ici un mois. Pour cette première échéance, nous devons présenter un "prototype allégé", donc quelque chose qui réalise une fonction donnée, mais sans détails, sans ajouts, sans fonctionnalités avancées, etc.

Nous ne ferons bien entendu pas de polyphonique d'ici l'échéance de février. Par contre, le polyphonique est une de nos options pour la phase qui précède la seconde échéance, durant laquelle on ajoute des fonctionnalités au programme. La création automatique d'accompagnement, ou la possibilité d'utiliser ce logiciel sur un système embarqué sans perte de temps réel, en sont d'autres. Mais nous n'avons pour l'instant aucun objectif "fixé" à ce sujet, ce sont nos études qui nous les feront déterminer.

Typiquement, il est fort possible que la séparation de sources en JAVA, indispensable au polyphonique, soit trop complexe à mettre en oeuvre et trop lente - ou que pour la rendre plus simple et plus rapide, il faille trop sacrifier du côté de la qualité et de l'efficacité. Nous verrons donc dans quelle mesure ça nous semble réalisable.

Citation:

---

Envoyé par Lyndor

Typiquement, il est fort possible que la séparation de sources en JAVA, indispensable au polyphonique, soit trop complexe à mettre en oeuvre et trop lente - ou que pour la rendre plus simple et plus rapide, il faille trop sacrifier du côté de la qualité et de l'efficacité. Nous verrons donc dans quelle mesure ça nous semble réalisable.

---

Personnelement j'ai essayé (mais je ne suis pas un expert dutout je m'amuse) la polyphonie aussi. La monophonie marchait impeccable avec toutes sorte de sons bien joué mais la polyphonie reste mon rêve pour fabriquer un petit "resynthetiseur". Mon programme actuel enregistre sur une entrée de la carte son, analyse la note et envoye un signal midi pour faire fonctionner un synthetiseur avec pas trop de latence...

En tout cas bonne chance et bon amusement.

On va bosser sur la séparation de source : notre défaut par rapport à toi, c'est que nous sommes tous de grands débutants en JAVA, pas compétents du tout de base.

Par contre, notre avantage, c'est que là où j'étudie, nous sommes entourés d'experts et de chercheurs en tout genre qui sont tout disposés à nous aider ^^ La séparation de source et le traitement de la polyphonie, ils le font très bien en matlab. Faut juste voir si on a le temps, si on veut le faire et si ça se convertit bien en JAVA.

Bon, et je ne pousserai pas le vice jusqu'à te demander si je pourrais jeter un coup d'oeil à ton programme ^^

Je vois ce que tu vx dire c'est bien d'avoir des "mathematiciens" a ses cotés pour ce genre de projet.

Sinon, Tu seras surpris mais je me suis servis d'un exemple fourni avec la librairie FMOD qui fait exactement la détection de notes.
Je l'ai un peu tweaké et rajoute une interface midi et une petit interface graphique tout simplement. En gros fmod fournit la FFT et tu te tracasse pas d'analyser le signal etc, tu recupere tes != bandes de frequences, tu regarde juste quelle est la bande qui a le plus d'"amplitudes".

Par contre je sais pas ou j'ai fourré les sources, mais tu px essayer la programme si tu es curieux http://renaud.warnotte.be/Projects/A...alogToMidi.rar

Ah, moi je pataugeais dans le package javax.sound.sampled - je vais regarder le lien que tu me fournis, merci =)

Ha ca peut être suffisant dans certains cas, mais moi si je vx jouer avec du son et faire un truc potable jusque la j'utilisais le binding Fmod de "Jouvieje" qui offre qd meme pas mal de chouettes truc deja tout fait. (des DSPs entres autres ainsi qu'une petite architecture modulaires pour les branchers ensemble).

Allez, je vous redérange, avec une question beaucoup plus centrée sur JAVA cette fois :

J'ai écris quelque chose de beaucoup plus simple que ce que souhaitais initialement : un programme qui prend un fichier WAV en entrée et qui stocke le contenu du fichier WAV dans un tableau.

Les programmes sont classiques, les voicis :

AudioTest :

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 100 101 102 103 104 105 106 107 108 109

package test; import java.io.File; import java.io.IOException;   import javax.sound.sampled.AudioFormat; import javax.sound.sampled.AudioInputStream; import javax.sound.sampled.AudioSystem; import javax.sound.sampled.DataLine; import javax.sound.sampled.LineUnavailableException; import javax.sound.sampled.SourceDataLine; import javax.sound.sampled.UnsupportedAudioFileException;   public class AudioTest implements Runnable {   private SourceDataLine line; private File file; private AudioInputStream audioInputStream; private AudioFormat audioFormat; private boolean stop=false;   public void stop() { stop=true; }   public void init(){   try { audioInputStream = AudioSystem.getAudioInputStream(file);   } catch (UnsupportedAudioFileException e) { e.printStackTrace(); return; } catch (IOException e) { e.printStackTrace(); return; }   //Il est nécessaire de connaître le format audio du fichier // d'entrée // pour permettre à java de créer l'objet DataLine adéquat audioFormat = audioInputStream.getFormat(); //System.out.println(audioFormat);   // En plus du format du flux audio d'entrée il est nécessaire de // spécifier le type de DataLine qu'on veut // ici le DataLine qu'on souhaite est un SourceDataLine qui permet // la // lecture (targetDataLine permet l'enregistrement).   DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);   // On récupère le DataLine adéquat et on l'ouvre try { line = (SourceDataLine) AudioSystem.getLine(info);   } catch (LineUnavailableException e) { e.printStackTrace(); return; } }   public void run() {   stop = false; // Avant toute chose il est nécessaire d'ouvrir la ligne try { line.open(audioFormat); } catch (LineUnavailableException e) { e.printStackTrace(); return; // TODO Auto-generated catch block   } // pour que le flux soit effectivement redirigé sur la carte son il // faut // demarrer la ligne line.start();   // il faut maintenant écrire sur la ligne. Travail comme sur un // inputStream quelconque try { byte bytes[] = new byte[1024]; int bytesRead=0; int i = 0; while (((bytesRead = audioInputStream.read(bytes, 0, bytes.length)) != -1) && !stop) {   System.out.println("échantillon : " + bytes[i]); i++; } } catch (IOException io) { io.printStackTrace(); return; }   }   public void setFile(File file) { this.file = file;   }   public SourceDataLine getLine() { return line; }     }

---

et AudioTestGUI :

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 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130

package test; import java.awt.BorderLayout; import java.awt.Dimension; import java.awt.event.ActionEvent; import java.io.File;   import javax.sound.sampled.LineEvent; import javax.sound.sampled.LineListener; import javax.swing.AbstractAction; import javax.swing.Action; import javax.swing.ImageIcon; import javax.swing.JFileChooser; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.JToolBar; import javax.swing.filechooser.FileFilter;     public class AudioTestGUI {   private Thread audioPlayerThread; private AudioTest player; private Action load; private Action play; private Action stop; private JFrame frame; private JPanel contentPane; private JFileChooser chooser; private File audioFile; private JLabel title;     public AudioTestGUI(){     player = new AudioTest(); frame = new JFrame("AudioPlayer"); contentPane = new JPanel(new BorderLayout()); chooser = new JFileChooser(); chooser.setFileFilter(new FileFilter() {   public boolean accept(File f) { if (f.getName().endsWith(".wav")) return true; else return false; }   public String getDescription() { return null; } });   contentPane.setPreferredSize(new Dimension(300, 150));   stop = new AbstractAction() {   public void actionPerformed(ActionEvent arg0) { player.stop(); } }; stop.putValue(Action.SMALL_ICON, new ImageIcon("stop.png"));     play= new AbstractAction() {   public void actionPerformed(ActionEvent arg0) {   player.init(); audioPlayerThread = new Thread(player); audioPlayerThread.start();   player.getLine().addLineListener(new LineListener(){   public void update(LineEvent le) { if(le.getType()==LineEvent.Type.STOP){ play.setEnabled(true); stop.setEnabled(false);     } if(le.getType()==LineEvent.Type.START){ play.setEnabled(false); stop.setEnabled(true);   } } });   } };   play.putValue(Action.SMALL_ICON, new ImageIcon("play.png"));   load = new AbstractAction() { public void actionPerformed(ActionEvent arg0) { int returnVal = chooser.showOpenDialog(frame); if (returnVal == JFileChooser.APPROVE_OPTION) {   audioFile=chooser.getSelectedFile(); player.setFile(audioFile); player.init(); title.setText("Fichier en cours de lecture: "+ audioFile.getName()); contentPane.paintAll(contentPane.getGraphics());   } } }; load.putValue(Action.SMALL_ICON, new ImageIcon("load.png"));   JToolBar toolbar = new JToolBar(); toolbar.add(load); toolbar.add(play); toolbar.add(stop);   contentPane.add(toolbar, BorderLayout.NORTH); title=new JLabel("Aucun titre en cours de lecture"); contentPane.add(title,BorderLayout.CENTER); frame.setContentPane(contentPane); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.pack(); frame.setVisible(true);   } public static void main(String[] args) { new AudioTestGUI(); }   }

---

Bon, le second sert juste à lancer le premier, en gros.

Comme vous pouvez le voir dans la première classe, mon programme se contente d'afficher les échantillons à l'écran - je voulais avoir un aperçu clair de ce que j'avais.


Et là, stupeur : je vais chercher un fichier WAV dans l'un de mes répertoires, je lance la lecture et il m'affiche un tas d'échantillons entre -128 et -128, c'est à dire un octet.

Ok, très bien, mais... Est-ce que je peux régler ça ? Est-ce qu'il y a un moyen qu'il me capture du 16 bits ? Concrètement, ça peut poser problème qu'il me capture des échantillons d'un octet, pour la restitution ? (sachant que je veux juste détecter les notes à partir de ces échantillons).


Deuxième question :

Ma condition d'arrêt d'affichage des échantillons, c'est ça :

while (((bytesRead = audioInputStream.read(bytes, 0, bytes.length)) != -1)
&& !stop)

Mais je trouve qu'il m'affiche bien peut d'échantillons : pour un fichier WAV qui joue de la musique pendant plusieurs secondes, je reçois seulement ça :

Citation:

---

échantillon : -128
échantillon : -128
échantillon : 127
échantillon : 126
échantillon : 124
échantillon : 118
échantillon : 103
échantillon : 73
échantillon : 125
échantillon : -126
échantillon : -115
échantillon : -116
échantillon : -121
échantillon : 126
échantillon : -113
échantillon : -92
échantillon : 102
échantillon : 119
échantillon : -70
échantillon : 118
échantillon : 92
échantillon : -63
échantillon : -120
échantillon : 99
échantillon : 92
échantillon : 107
échantillon : -103
échantillon : 87
échantillon : 88
échantillon : 82
échantillon : 119
échantillon : -120
échantillon : 105
échantillon : 107
échantillon : 78
échantillon : -126
échantillon : 79
échantillon : -105
échantillon : 117
échantillon : 116
échantillon : -104
échantillon : -118
échantillon : 127
échantillon : -127
échantillon : -125
échantillon : -120
échantillon : -99
échantillon : -124
échantillon : -100
échantillon : -124
échantillon : -97
échantillon : -125
échantillon : -121
échantillon : -102
échantillon : 108
échantillon : 104
échantillon : 108
échantillon : 113
échantillon : -114
échantillon : -116
échantillon : -106
échantillon : 117
échantillon : -118
échantillon : 127
échantillon : 119
échantillon : -116
échantillon : -120
échantillon : 114
échantillon : -127
échantillon : -121
échantillon : -97
échantillon : 119
échantillon : -108
échantillon : -119
échantillon : -125
échantillon : 104
échantillon : 107
échantillon : -101
échantillon : -111
échantillon : -123
échantillon : 118
échantillon : -111
échantillon : -117
échantillon : -124
échantillon : 108
échantillon : -115
échantillon : -120
échantillon : -105
échantillon : -109
échantillon : -114
échantillon : -105
échantillon : 113
échantillon : -125
échantillon : 126
échantillon : -125
échantillon : 111
échantillon : -111
échantillon : -121
échantillon : 127
échantillon : -116
échantillon : 121
échantillon : 119
échantillon : 125
échantillon : -107
échantillon : 115
échantillon : -106
échantillon : -120
échantillon : 120
échantillon : -94
échantillon : -124
échantillon : 118
échantillon : 118
échantillon : -116
échantillon : -121
échantillon : 98
échantillon : 115
échantillon : 116
échantillon : -94
échantillon : 121
échantillon : 123
échantillon : 104
échantillon : 116
échantillon : 123
échantillon : -122
échantillon : -128
échantillon : -127
échantillon : 127

---

C'est normal que j'en reçoive aussi peu ? Concrètement, il est important que je laisse la commande audioInputStream.read(bytes, 0, bytes.length)) != -1 ?


Voilà tout, merci d'avance de vos réponses =)

Oh et, Wax78, il est génial ton programme ^^ Si tu retrouves les sources, ça m'intéresse grandement - je ne code pas le mien de la même façon dans tous les cas, mais découvrir un autre moyen de le faire me plairait beaucoup. Si tu ne souhaites pas les partager, ça ne me pose aucun problème.

Hum, je n'aime usuellement pas faire de doubles posts, mais j'aurais vraiment besoin d'une réponse à ma question =/

Je rappelle que je ne m'y connais pas en traitement du son, mais les questions semblent avoir une réponse évidente, je me permets donc de les donner :

Citation:

---

Envoyé par Lyndor

Et là, stupeur : je vais chercher un fichier WAV dans l'un de mes répertoires, je lance la lecture et il m'affiche un tas d'échantillons entre -128 et -128, c'est à dire un octet.

Ok, très bien, mais... Est-ce que je peux régler ça ? Est-ce qu'il y a un moyen qu'il me capture du 16 bits ? Concrètement, ça peut poser problème qu'il me capture des échantillons d'un octet, pour la restitution ? (sachant que je veux juste détecter les notes à partir de ces échantillons).

---

Tu sais, quand on met deux octets de 8 bits côte à côte, ça fait un échantillon de 16 bits.

Citation:

---

Envoyé par Lyndor

Deuxième question :

Ma condition d'arrêt d'affichage des échantillons, c'est ça :

Code:

---

1 2	while (((bytesRead = audioInputStream.read(bytes, 0, bytes.length)) != -1) && !stop)

---

Mais je trouve qu'il m'affiche bien peut d'échantillons

---

En même temps, plutôt que d'afficher un seul octet à chaque appel de read(), ce serait pas mal d'afficher tous ceux qui ont été lus.

Citation:

---

Envoyé par Lyndor

C'est normal que j'en reçoive aussi peu ?

---

Tu en reçois bien plus que cela, mais tu n'en affiches qu'un seul par boucle.

Merci pour cette réponse =) Comme je l'avais précisé, je suis débutant en JAVA, ainsi qu'en informatique de manière générale, je tâtonne donc beaucoup et me perd facilement.

Saurais-tu me dire comment modifier le code de façon à afficher tous les octets stockés ? Et sinon, considérant que sous cette forme il stocke déjà tous les octets d'après ce que tu dis, normalement tout fonctionne correctement si j'envoie directement le tableau bytes à l'algorithme ?