IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

avec Java Discussion :

Lire un son WAV


Sujet :

avec Java

  1. #1
    Membre du Club
    Inscrit en
    novembre 2006
    Messages
    150
    Détails du profil
    Informations personnelles :
    Âge : 34

    Informations forums :
    Inscription : novembre 2006
    Messages : 150
    Points : 48
    Points
    48
    Par défaut Lire un son WAV
    Bonjour à tous,
    j'ai récupéré sur Internet un code source qui permet en théorie d'ouvrir un fichier audio et de l'arrêter. Seulement je n'arrive même pas à le faire fonctionner Donc je vous mets le code, dites moi s'il faut des import particuliers (autres que ceux présents xD) , installer des bibliothèques pour l'audio, ou autre chose ^^ ...

    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
     
    import java.io.File;
     
     import javax.sound.sampled.AudioFormat;
     import javax.sound.sampled.AudioInputStream;
     import javax.sound.sampled.AudioSystem;
     import javax.sound.sampled.Clip;
     import javax.sound.sampled.DataLine;
     
     
     public class WavPlayer {    
     
         private Clip clip = null;
         private AudioInputStream audioStream = null;
     
         public WavPlayer(File f) throws Exception{
             audioStream = AudioSystem.getAudioInputStream(f);//recuperation d'un stream de type audo sur le fichier
             AudioFormat audioFormat = audioStream.getFormat();//recuperation du format de son
             //recuperation du son que l'on va stoquer dans un oblet de type clip
             DataLine.Info info = new DataLine.Info(
                     Clip.class, audioStream.getFormat(),
                     ((int) audioStream.getFrameLength() * audioFormat.getFrameSize()));
             //recuperation d'une instance de type Clip
             clip = (Clip) AudioSystem.getLine(info);
     
         }
     
         /**
          * Ouverture du flux audio
          * @return On retourne <code>false</code> si il y a eu une erreure
          */
         public boolean open(){
             if(clip != null && !clip.isOpen())//teste pour ne pas le faire dans le vent
                 try {
                     clip.open(audioStream);
                 } catch (Exception e) {
                     e.printStackTrace();//pour le debugage
                     return false;
                 }
             return true;
         }
     
         /**
          * Fermeture du flux audio
          */
         public void close(){
             if(clip != null && clip.isOpen())//teste pour ne pas le faire dans le vent
                 clip.close();
         }
     
         /**
          * On joue le son
          */
         public void play(){
             if(clip != null && clip.isOpen())
                 clip.start();
         }
     
         /**
          * On arrete le son
          */
         public void stop(){
             if(clip != null && clip.isOpen())
                 clip.stop();
         }
     
     
         public static void main(String [] args){
     
     
        	 try {
                 WavPlayer wp = new WavPlayer(new File("musique1.wav"));
                 wp.open();//ouverture du flux
                 wp.play();//lecture
                 wp.stop();//arret
                 wp.close();//pour etre propre on ferme le flux quand il n'est plus utile :D
             System.out.println("debug0");
        	 } catch (Exception e) {
                 e.printStackTrace();
             }
     
         }
     }
    mon compilateur m'affiche très bien mon petit "debug0" donc à priori pas d'erreurs de codage ^^

    Voili voilou, merci d'avance pour vos réponses

  2. #2
    Membre régulier
    Profil pro
    Développeur informatique
    Inscrit en
    novembre 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : novembre 2008
    Messages : 108
    Points : 104
    Points
    104
    Par défaut
    quand tu dit ça ne fonctionne pas

    a tu un message d'erreur quelque part ? si oui poste le

    sinon ton fichier musique1.wav est-il bien dans le même dossier que tes source ? en gros le chemin d'accès est-il le bon pour accéder à ce fichier ?

    Aussi je viens de voir, dans le main tu fait un wp.play() suivi d'un wp.stop()

    en fait tu lance la musique et tu l'arrête tout de suite après c'est peu être pour ça que ça ne tourne pas ? peut-être faut-il mettre une condition avant de stopper ta musique ? (attendre la fin de la chanson ?)

    je n'ai jamais utiliser ses lib, mais tout les import on l'air bon (sinon ça ne compilerai pas de toute manière)

    cdlt

  3. #3
    Membre du Club
    Inscrit en
    novembre 2006
    Messages
    150
    Détails du profil
    Informations personnelles :
    Âge : 34

    Informations forums :
    Inscription : novembre 2006
    Messages : 150
    Points : 48
    Points
    48
    Par défaut
    ben j'ai testé avec la musique dans le répertoire "src" , "bin", et dans la racine du projet, mais toujours rien ...
    D'autre part, quand je dis que ça ne "marche pas", c'est en réalité que je n'entends aucun son
    J'ai bien sur essayé en mettant l'appel des fonctions stop() et close() en commentaire, mais ça n'a rien donné ...

    En tout cas merci de m'avoir répondu

  4. #4
    Membre régulier
    Profil pro
    Développeur informatique
    Inscrit en
    novembre 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : novembre 2008
    Messages : 108
    Points : 104
    Points
    104
    Par défaut
    bon ben je test ton code en rentrant du boulot, et je posterai à la suite pour te donner le résultat de mes test

    petit edit : à tout hasard a tu essayé de mettre des petit println dans tes fonction open() play() ... juste pour être sur que tu rentre dedans ?

    par exemple si tu récupère un null sur ton clip tu ne pourra pas ouvrir le fichier ... ce qui peut être causé a mon avis si le format de ton son n'est pas reconnu

  5. #5
    Membre du Club
    Inscrit en
    novembre 2006
    Messages
    150
    Détails du profil
    Informations personnelles :
    Âge : 34

    Informations forums :
    Inscription : novembre 2006
    Messages : 150
    Points : 48
    Points
    48
    Par défaut
    j'ai placé tout plein de println , tous sont executés ^^
    ...

  6. #6
    Membre régulier
    Profil pro
    Développeur informatique
    Inscrit en
    novembre 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : novembre 2008
    Messages : 108
    Points : 104
    Points
    104
    Par défaut
    bon après vérification le problème vient bien du temps de lecture du main

    en gros il fait play suivi de stop suivi de close et tout ca se fait très rapidement et donc ne te fait pas écouter grand chose

    si juste après le play() tu ajoute

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    ...
    int i = 0;
    while(i<10){
    Thread.sleep(1000); // fait patienter une seconde
    }
    ...
    tu entendra les 10 première seconde de ton enregistrement.

    maintenant pour entendre toute la durée de l'enregistrement essaye ceci (sans devoir spécifier le temps de lecture par toi même ^^ ce sera plus utile):

    je n'utilise plus le Clip
    je te poste le code final qui fonctionne chez moi, à toi de tester maintenant

    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
     
    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.Clip;
    import javax.sound.sampled.DataLine;
    import javax.sound.sampled.LineUnavailableException;
    import javax.sound.sampled.SourceDataLine;
     
     
     public class WavPlayer {    
     
         private AudioInputStream audioStream = null;
         private SourceDataLine line = null;
         private AudioFormat audioFormat = null;
     
         public WavPlayer(File f) throws Exception{
             audioStream = AudioSystem.getAudioInputStream(f);
             audioFormat = audioStream.getFormat();
             DataLine.Info info = new DataLine.Info(SourceDataLine.class,audioFormat);
     
             try {
             line = (SourceDataLine) AudioSystem.getLine(info);
             } catch (LineUnavailableException e) {
    		     e.printStackTrace();
             }		
         }
     
         /**
          * Ouverture du flux audio
          * @return On retourne <code>false</code> si il y a eu une erreure
          */
         public boolean open(){
     
                 try {
                	 line.open(audioFormat);
                 } catch (Exception e) {
                     e.printStackTrace();//pour le debugage
                     return false;
                 }
             return true;
         }
     
         /**
          * Fermeture du flux audio
          */
         public void close(){
             line.stop();
         }
     
         /**
          * On joue le son
          */
         public void play(){
        	 line.start();
             try {
     			byte bytes[] = new byte[1024];
     				int bytesRead=0;
     				while (((bytesRead = audioStream.read(bytes, 0, bytes.length)) != -1)) {
     					line.write(bytes, 0, bytesRead);
     				}
     			} catch (IOException io) {
     				io.printStackTrace();
     				return;
     			}
     
         }
     
         /**
          * On arrete le son
          */
         public void stop(){
        	 line.close();
         }
     
     
         public static void main(String [] args){
     
     
        	 try {
                 WavPlayer wp = new WavPlayer(new File("D:\\Documents and Settings\\...\\Bureau\\musique.wav"));
                 wp.open();
                 wp.play();           
                 wp.stop();
                 wp.close();
             System.out.println("debug0");
        	 } catch (Exception e) {
                 e.printStackTrace();
             }
     
         }
     }
    ce que j'ai changé donc :

    1) je n'utilise plus les clip, ca ne fonctionnait pas sur ma machine
    2) changer le DataLine.Info info pour ne plus utliser le clip
    3) créer variable SourceDataLine line pour la lecture du fichier audio
    3 bis) remplacement de tout ce qui faisait appel au "clip" par mon "line"
    4) rajout d'une boucle
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    byte bytes[] = new byte[1024];
     				int bytesRead=0;
     				while (((bytesRead = audioStream.read(bytes, 0, bytes.length)) != -1)) {
     					line.write(bytes, 0, bytesRead);
    cette boucle permet de lire tout le fichier avant de s'areter ( après a toi de regler des bouton ou des evenement pour couper le son quand tu le désire si tu ne veux pas jouer le son en entier)


    voila je pensse que c'est tout

    n'hésite pas si tu as des questions

  7. #7
    Membre du Club
    Inscrit en
    novembre 2006
    Messages
    150
    Détails du profil
    Informations personnelles :
    Âge : 34

    Informations forums :
    Inscription : novembre 2006
    Messages : 150
    Points : 48
    Points
    48
    Par défaut
    nikel j'arrive à lancer la musique
    par contre je n'arrive pas à l'arrêter ...
    la fonction ne fonctionne pas ...

  8. #8
    Membre régulier
    Profil pro
    Développeur informatique
    Inscrit en
    novembre 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : novembre 2008
    Messages : 108
    Points : 104
    Points
    104
    Par défaut
    j'ai inversé dans la fonction close fait un line.close() et dans la fonction stop un line.stop() moi j'ai fait l'inverse (erreur d'inattention)

  9. #9
    Membre du Club
    Inscrit en
    novembre 2006
    Messages
    150
    Détails du profil
    Informations personnelles :
    Âge : 34

    Informations forums :
    Inscription : novembre 2006
    Messages : 150
    Points : 48
    Points
    48
    Par défaut
    Citation Envoyé par deglingo592003 Voir le message
    j'ai inversé dans la fonction close fait un line.close() et dans la fonction stop un line.stop() moi j'ai fait l'inverse (erreur d'inattention)
    oui je l'avais changé

    le problème est que la fonction play() ne rend pas la main. Aucun println n'est exécuté ("stop" et "close") ... Je ne sais pas trop comment faire pour pouvoir arrêter le son quand j'en ai envie

    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
     
    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.Clip;
    import javax.sound.sampled.DataLine;
    import javax.sound.sampled.LineUnavailableException;
    import javax.sound.sampled.SourceDataLine;
     
     
     public class WavPlayer {    
     
         private AudioInputStream audioStream = null;
         private SourceDataLine line = null;
         private AudioFormat audioFormat = null;
     
         public WavPlayer(File f) throws Exception{
             audioStream = AudioSystem.getAudioInputStream(f);
             audioFormat = audioStream.getFormat();
             DataLine.Info info = new DataLine.Info(SourceDataLine.class,audioFormat);
     
             try {
             line = (SourceDataLine) AudioSystem.getLine(info);
             } catch (LineUnavailableException e) {
    		     e.printStackTrace();
             }		
         }
     
         /**
          * Ouverture du flux audio
          * @return On retourne <code>false</code> si il y a eu une erreure
          */
         public boolean open(){
     
                 try {
                	 line.open(audioFormat);
                 } catch (Exception e) {
                     e.printStackTrace();//pour le debugage
                     return false;
                 }
             return true;
         }
     
         /**
          * Fermeture du flux audio
          */
         public void close(){
        	 System.out.println("close");
        	 line.close();
         }
     
         /**
          * On joue le son
          */
         public void play(){
        	 line.start();
             try {
     			byte bytes[] = new byte[1024];
     				int bytesRead=0;
     				while (((bytesRead = audioStream.read(bytes, 0, bytes.length)) != -1)) {
     					line.write(bytes, 0, bytesRead);
     				}
     			} catch (IOException io) {
     				io.printStackTrace();
     				return;
     			}
     
         }
     
         /**
          * On arrete le son
          */
         public void stop(){
        	 System.out.println("stop");
        	 line.stop();
     
        	     }
     
     
     
     }

  10. #10
    Membre régulier
    Profil pro
    Développeur informatique
    Inscrit en
    novembre 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : novembre 2008
    Messages : 108
    Points : 104
    Points
    104
    Par défaut
    étant donnée que dans le play on boucle jusqu'à la fin de la chanson en gros ...

    donc en fait c'est normale que le reste n'est pas effectué

    il faudrait mettre une condition d'arrêt, comme par exemple avec un booléen qui permettrai d'interrompre la chanson quand ce booléen change de valeur?

    j'y réfléchirai un peu plus d'ici ce soir a moins que tu trouve la solution par toi même

    car en y pensant avec une interface graphique avec un listener sur un bouton stop qui ferait stopper la chanson ça se fait facilement ... maintenant sans interface avec juste un code qui s'exécute de façon linéaire ... j'ai pas la solution en tête

    edit : sinon en exécutant le play avec un thread ... sa pourrai être une solution non ?

  11. #11
    Membre du Club
    Inscrit en
    novembre 2006
    Messages
    150
    Détails du profil
    Informations personnelles :
    Âge : 34

    Informations forums :
    Inscription : novembre 2006
    Messages : 150
    Points : 48
    Points
    48
    Par défaut
    Citation Envoyé par deglingo592003 Voir le message
    car en y pensant avec une interface graphique avec un listener sur un bouton stop qui ferait stopper la chanson ça se fait facilement ...
    Ben c'est ce que j'ai : une interface graphique lol
    Mais bon que la fonction stop() soit appelé avec un listener ou directement dans le main, je ne vois pas ce que ça change ... Le problème vient du play() qui ne veut pas rendre la main ( mais donne la papatte enfin !!! )

  12. #12
    Membre régulier
    Profil pro
    Développeur informatique
    Inscrit en
    novembre 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : novembre 2008
    Messages : 108
    Points : 104
    Points
    104
    Par défaut
    dans ce cas là, un Thread qui s'occupe du play permettra donc de récupérer la main dès que le play est lancé.

    ensuite avec ton bouton stop la ça devrai fonctionner non ?

    je testerai ça chez moi surement ce soir

    car le problème vient bien du fait que :

    tu initialise ...
    tu appelle la fonction play
    play boucle jusqu'à la fin de la chanson
    ensuite elle rend la main

    avec un thread tu aurai
    tu initialise ...
    tu appelle la fonction play ET le programme reprend la main
    le thread s'occupe de la lecture jusqu'à la fin de la chanson chanson sauf si on fait un line.stop()

    (et la ta variable line serait partagé entre ton thread et ton programme comme cela dans ton programme principale tu change line quand tu veux arrêter la musique .. et en revanche ton thread lui lit jusqu'à ce qu'il arrive a la fin sauf si line est arrêter en cour de route)

    enfin je verrai quelque chose comme cela ... ou qui y ressemble

  13. #13
    Membre du Club
    Inscrit en
    novembre 2006
    Messages
    150
    Détails du profil
    Informations personnelles :
    Âge : 34

    Informations forums :
    Inscription : novembre 2006
    Messages : 150
    Points : 48
    Points
    48
    Par défaut
    Citation Envoyé par deglingo592003 Voir le message
    dans ce cas là, un Thread qui s'occupe du play permettra donc de récupérer la main dès que le play est lancé.
    [...]
    enfin je verrai quelque chose comme cela ... ou qui y ressemble
    Entièrement d'accord , mais je n'arrive pas à mettre en place mon thread
    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
     
    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.Clip;
     import javax.sound.sampled.DataLine;
     import javax.sound.sampled.LineUnavailableException;
     import javax.sound.sampled.SourceDataLine;
     
     
    public class WavPlayer extends Thread{
    	 private AudioInputStream audioStream = null;
         private SourceDataLine line = null;
         private AudioFormat audioFormat = null;  
    	 private boolean isRunning;
     
     
    	 public WavPlayer(File f) throws Exception{
    		 super();
    		 isRunning=false;
    		 audioStream = AudioSystem.getAudioInputStream(f);
             audioFormat = audioStream.getFormat();
             DataLine.Info info = new DataLine.Info(SourceDataLine.class,audioFormat);
     
             try {
             line = (SourceDataLine) AudioSystem.getLine(info);
             } catch (LineUnavailableException e) {
    		     e.printStackTrace();
             }		
         } 
     
     
     
    	  public void run(){
    	     isRunning=true;
     
    	     while(isRunning){
    	    	 line.start();
    	         try {
    	 			byte bytes[] = new byte[1024];
    	 				int bytesRead=0;
    	 				while (((bytesRead = audioStream.read(bytes, 0, bytes.length)) != -1)) {
    	 					if (isRunning) line.write(bytes, 0, bytesRead);
    	 				}
    	 			} catch (IOException io) {
    	 				io.printStackTrace();
    	 				return;
    	 			}
    	     }
    	  }
     
    	  public void setRunning(boolean isRunning){
    	    this.isRunning=isRunning;
    	  }
     
     
     
         public boolean open(){
     
                 try {
                	 line.open(audioFormat);
                 } catch (Exception e) {
                     e.printStackTrace();//pour le debugage
                     return false;
                 }
             return true;
         }
     
     
         /**
          * Fermeture du flux audio
          */
         public void close(){
        	 System.out.println("close");
        	 line.close();
     
         }
     
     
     
        	     }

  14. #14
    Membre régulier
    Profil pro
    Développeur informatique
    Inscrit en
    novembre 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : novembre 2008
    Messages : 108
    Points : 104
    Points
    104
    Par défaut
    il ne faut pas tout passer ta class en thread mais juste la méthode play

    car la ce que tu as fait revient au même

    le thread permet a la fonction play de s'exécuter en parallèle sans bloquer le reste de ton programme...

    voila ce qui fonctionne chez moi après changement

    j'ai créer une classe appelé "MonThread" qui extend Thread

    le fichier MonThread :

    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
     
    import java.io.IOException;
     
     
    public class MonThread extends Thread{
     
    	public MonThread(){
    	}
     
    	public void run(){
    		WavPlayer.line.start();
    		 try {
    	 			byte bytes[] = new byte[1024];
    	 				int bytesRead=0;
    	 				while (((bytesRead = WavPlayer.audioStream.read(bytes, 0, bytes.length)) != -1)) {
    	 					WavPlayer.line.write(bytes, 0, bytesRead);
    	 				}
    	 			} catch (IOException io) {
    	 				io.printStackTrace();
    	 				return;
    	 			}
     
    	}
    }
    et la classe WavPlayer :

    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
     
    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;
     
     
     public class WavPlayer {    
     
         public static AudioInputStream audioStream = null;
         public static SourceDataLine line = null;
         private AudioFormat audioFormat = null;
     
         public WavPlayer(File f) throws Exception{
             audioStream = AudioSystem.getAudioInputStream(f);
             audioFormat = audioStream.getFormat();
             DataLine.Info info = new DataLine.Info(SourceDataLine.class,audioFormat);
     
             try {
             line = (SourceDataLine) AudioSystem.getLine(info);
             } catch (LineUnavailableException e) {
    		     e.printStackTrace();
             }		
         }
     
         /**
          * Ouverture du flux audio
          * @return On retourne <code>false</code> si il y a eu une erreure
          */
         public boolean open(){
     
                 try {
                	 line.open(audioFormat);
                 } catch (Exception e) {
                     e.printStackTrace();//pour le debugage
                     return false;
                 }
             return true;
         }
     
         /**
          * Fermeture du flux audio
          */
         public void close(){
             line.close();
         }
     
         /**
          * On joue le son
          */
         public void play(){
     
        	 MonThread t = new MonThread();
        	 t.start();	
        	 System.out.println("test");
         }
     
         /**
          * On arrete le son
          */
         public void stop(){
        	 line.stop();
         }
     
     
         public static void main(String [] args){
     
     
        	 try {
                 WavPlayer wp = new WavPlayer(new File("D:\\Documents and Settings\\romain\\Bureau\\musique.wav"));
                 wp.open();
                 wp.play();
                 int i = 0;
                 while(i < 5){
                	 Thread.sleep(1000);
                	 System.out.println(i);
                	 i++;
                 }
                 wp.stop();
                 wp.close();
             System.out.println("debug0");
        	 } catch (Exception e) {
                 e.printStackTrace();
             }
     
         }
     }
    les changements apportés :

    création de la classe Monthread qui s'occupe exactement de ce que faisait la fonction play()

    ensuite dans le fichier WavPlayer :
    passage de variable audioStream et line en variable public static pour partager ses variable avec le thread

    ensuite dans la méthode play() :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
     public void play(){
     
        	 MonThread t = new MonThread();
        	 t.start();	
        	 System.out.println("test");
         }
    j'instancie le thread et je le lance (ce qui a pour effet de lancer la méthode run
    donc le thread se lance en parallèle mais renvoie tout de suite la main au programme qui continue (affiche le println("test"))

    Pour ce qui est du main j'ai rajouter juste une petite boucle pour mon test

    pour ce test j'ai un wav de 15seconde
    la boucle en fait boucle pendant 5 secondes ... au bout des 5 secondes
    on sort de la boucle et fait appelle au la fonction stop qui fait un line.stop()

    ce qui remplace le listener sur ton bouton stop ...

    avec ça, lorsque tu appuiera sur ton bouton il devrai bien stopper ta musique

    tien moi au courant pour la suite

  15. #15
    Membre du Club
    Inscrit en
    novembre 2006
    Messages
    150
    Détails du profil
    Informations personnelles :
    Âge : 34

    Informations forums :
    Inscription : novembre 2006
    Messages : 150
    Points : 48
    Points
    48
    Par défaut
    ça a l'air de marcher ...
    je teste ça sur mon gros projet et jte tiens au courant

    EDIT : OH MY GOD !!!! ça marche impec ^^
    merci pour tout le temps que tu as pris pour m'aider . Décidemment je kiffe ce site
    A plushhhh et merci encore

  16. #16
    Membre du Club
    Inscrit en
    novembre 2006
    Messages
    150
    Détails du profil
    Informations personnelles :
    Âge : 34

    Informations forums :
    Inscription : novembre 2006
    Messages : 150
    Points : 48
    Points
    48
    Par défaut
    Nouveau problème !!
    j'aimerais laisser jouer ma playlist tabMusique[] tant que je ne clique pas sur mon bouton "arreter musique" (situé dans ma fenetre) ...
    On surveille cela grace au booleen "musique".
    Ce problème n'est -selon moi - qu'un problème d'algo

    Dans mon Test.java j'ai :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
      while(MonThread.fin_musique == false) 
             {}
    qui me permet de lire ma 2eme musique juste apr_s la premiere. Mais à partir de la troisième ça part en sucette

    jte met ton mon code ça peut servir :
    Test.java :
    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
    import java.io.File;
    import javax.sound.sampled.AudioFormat;
    import javax.sound.sampled.AudioInputStream;
    import javax.sound.sampled.AudioSystem;
    import javax.sound.sampled.Clip;
    import javax.sound.sampled.DataLine;
     
    import javax.swing.JFrame;
    import javax.swing.JPanel;
     
     
    public class Test {
     
            public static void main(String[] args) throws Exception{
     
         String Nom = null ;
     
      String tabMusique[]= new String [5];
      WavPlayer wp;
     
      tabMusique[0]= "coyote.wav" ;
      tabMusique[1]= "coyote.wav" ;
      tabMusique[2]= "coyote.wav" ;
      tabMusique[3]= "coyote.wav" ;
      tabMusique[4]= "musique5.wav" ;
     
     int  i = 0 , j =0;
         //Creation de ma fenêtre
          	 Fenetre fen = new Fenetre(Nom); 
     
          do{	 // tant qu'on a pas cliqué sur jouer
     
        if (fen.musique) // si on clique sur "lancer musique"
     
     
      {
     
         try 
         {
        	 while (fen.musique==true){
     
     
     
             wp = new WavPlayer(new File(tabMusique[i]));
             i++ ;
     
     
             if(i==5) i=0 ; // RAZ compteur playtist
     
             wp.open();
             System.out.println("zik open");
             wp.play();
             System.out.println("zik play / i ="+i);
     
         while(MonThread.fin_musique == false) 
           {} 
     
         MonThread.fin_musique = false ;
     
             Thread.sleep(1000); 	        	 
     
             wp.stop();
             System.out.println("zik stop");
             wp.close();
             System.out.println("zik close");
       }
    	 } catch (Exception e) {
             e.printStackTrace();
         }
     
      }          
          }
       while (fen.jouer==false)  ;     
     
     
            }
            }
     
     
    }
    WavPlayer :
    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
     
    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;
     
     
     public class WavPlayer {    
     
         public static AudioInputStream audioStream = null;
         public static SourceDataLine line = null;
         private AudioFormat audioFormat = null;
     
         public WavPlayer(File f) throws Exception{
             audioStream = AudioSystem.getAudioInputStream(f);
             audioFormat = audioStream.getFormat();
             DataLine.Info info = new DataLine.Info(SourceDataLine.class,audioFormat);
     
             try {
             line = (SourceDataLine) AudioSystem.getLine(info);
             } catch (LineUnavailableException e) {
    		     e.printStackTrace();
             }		
         }
     
         /**
          * Ouverture du flux audio
          * @return On retourne <code>false</code> si il y a eu une erreure
          */
         public boolean open(){
     
                 try {
                	 line.open(audioFormat);
                 } catch (Exception e) {
                     e.printStackTrace();//pour le debugage
                     return false;
                 }
             return true;
         }
     
         /**
          * Fermeture du flux audio
          */
         public void close(){
             line.close();
         }
     
         /**
          * On joue le son
          */
         public void play(){
     
        	 MonThread t = new MonThread();
        	 t.start();	
     
         }
     
         /**
          * On arrete le son
          */
         public void stop(){
        	 line.stop();
         }
     
     
     
     }
    Voili voilou, si tu vois comment faire , moi j'y est passé ma soirée jusqu'a 2h hier lol ! Là j'avoue je sèche un peu



    EDIT : ALELUHIAAA
    j'ai trouvé : j'ai du mettre MonThread.fin_musique = false en début de boucle; parce que il passait true une fois (dans le thread, en fin de musique), mais n'était jamais remis à false.
    Par contre je n'arrive plus à stoper ma musique de manière asynchrone (avec mon bouton "stop")...

    EDIT bis : C'est bon, j'écrit dans un fichier et je scrute si le fichier texte contient "f" (false) ou "t" (true). Je peux donc directement sortir de ma boucle (break)

  17. #17
    Futur Membre du Club
    Profil pro
    Inscrit en
    décembre 2008
    Messages
    5
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : décembre 2008
    Messages : 5
    Points : 5
    Points
    5
    Par défaut Super bout de programme
    Citation Envoyé par deglingo592003 Voir le message
    il ne faut pas tout passer ta class en thread mais juste la méthode play

    car la ce que tu as fait revient au même

    le thread permet a la fonction play de s'exécuter en parallèle sans bloquer le reste de ton programme...

    voila ce qui fonctionne chez moi après changement

    j'ai créer une classe appelé "MonThread" qui extend Thread

    le fichier MonThread :

    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
     
    import java.io.IOException;
     
     
    public class MonThread extends Thread{
     
    	public MonThread(){
    	}
     
    	public void run(){
    		WavPlayer.line.start();
    		 try {
    	 			byte bytes[] = new byte[1024];
    	 				int bytesRead=0;
    	 				while (((bytesRead = WavPlayer.audioStream.read(bytes, 0, bytes.length)) != -1)) {
    	 					WavPlayer.line.write(bytes, 0, bytesRead);
    	 				}
    	 			} catch (IOException io) {
    	 				io.printStackTrace();
    	 				return;
    	 			}
     
    	}
    }
    et la classe WavPlayer :

    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
     
    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;
     
     
     public class WavPlayer {    
     
         public static AudioInputStream audioStream = null;
         public static SourceDataLine line = null;
         private AudioFormat audioFormat = null;
     
         public WavPlayer(File f) throws Exception{
             audioStream = AudioSystem.getAudioInputStream(f);
             audioFormat = audioStream.getFormat();
             DataLine.Info info = new DataLine.Info(SourceDataLine.class,audioFormat);
     
             try {
             line = (SourceDataLine) AudioSystem.getLine(info);
             } catch (LineUnavailableException e) {
    		     e.printStackTrace();
             }		
         }
     
         /**
          * Ouverture du flux audio
          * @return On retourne <code>false</code> si il y a eu une erreure
          */
         public boolean open(){
     
                 try {
                	 line.open(audioFormat);
                 } catch (Exception e) {
                     e.printStackTrace();//pour le debugage
                     return false;
                 }
             return true;
         }
     
         /**
          * Fermeture du flux audio
          */
         public void close(){
             line.close();
         }
     
         /**
          * On joue le son
          */
         public void play(){
     
        	 MonThread t = new MonThread();
        	 t.start();	
        	 System.out.println("test");
         }
     
         /**
          * On arrete le son
          */
         public void stop(){
        	 line.stop();
         }
     
     
         public static void main(String [] args){
     
     
        	 try {
                 WavPlayer wp = new WavPlayer(new File("D:\\Documents and Settings\\romain\\Bureau\\musique.wav"));
                 wp.open();
                 wp.play();
                 int i = 0;
                 while(i < 5){
                	 Thread.sleep(1000);
                	 System.out.println(i);
                	 i++;
                 }
                 wp.stop();
                 wp.close();
             System.out.println("debug0");
        	 } catch (Exception e) {
                 e.printStackTrace();
             }
     
         }
     }
    les changements apportés :

    création de la classe Monthread qui s'occupe exactement de ce que faisait la fonction play()

    ensuite dans le fichier WavPlayer :
    passage de variable audioStream et line en variable public static pour partager ses variable avec le thread

    ensuite dans la méthode play() :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
     public void play(){
     
        	 MonThread t = new MonThread();
        	 t.start();	
        	 System.out.println("test");
         }
    j'instancie le thread et je le lance (ce qui a pour effet de lancer la méthode run
    donc le thread se lance en parallèle mais renvoie tout de suite la main au programme qui continue (affiche le println("test"))

    Pour ce qui est du main j'ai rajouter juste une petite boucle pour mon test

    pour ce test j'ai un wav de 15seconde
    la boucle en fait boucle pendant 5 secondes ... au bout des 5 secondes
    on sort de la boucle et fait appelle au la fonction stop qui fait un line.stop()

    ce qui remplace le listener sur ton bouton stop ...

    avec ça, lorsque tu appuiera sur ton bouton il devrai bien stopper ta musique

    tien moi au courant pour la suite
    Bonjour,
    je débute en java et je viens de trouver ce bout de code, qui correspond exactement à mon niveau , j'ai une question à vous poser ; comment faire la même chose avec des mp3
    merci d'avance
    Bricolomi

  18. #18
    Membre à l'essai
    Inscrit en
    août 2009
    Messages
    30
    Détails du profil
    Informations forums :
    Inscription : août 2009
    Messages : 30
    Points : 11
    Points
    11
    Par défaut
    Bonjour,

    j'ai testé votre code, il marche pour un seul fichier. Mais quanq aux autres une exception se lève dit que:

    javax.sound.sampled.UnsupportedAudioFileException: could not get audio input stream from input file
    at javax.sound.sampled.AudioSystem.getAudioInputStream(Unknown Source)
    at WavPlayer.<init>(WavPlayer.java:24)
    at WavPlayer.main(WavPlayer.java:92)

    oui, il s'agit de UnsupportedAudioFileException qui se lève lorseque l'opération échoue à cause qu'un fichier ne contient pas de données valides (d’un type de fichier reconnu et le format).

    mais par quoi puis-je savoir si un fichier contient des données valides ? et si je veux que ce programme lit tous les fichiers wave, quest-ce que je peux ajouter pour résoudre ce problème ?

    Merci d'avance

  19. #19
    Membre régulier
    Profil pro
    Développeur informatique
    Inscrit en
    novembre 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : novembre 2008
    Messages : 108
    Points : 104
    Points
    104
    Par défaut
    pour ahaile35 et Sendmi

    le code spécifié au dessus ne permet de lire que des fichier au format wav ( a savoir que ce n'est pas parce que le fichier fini par .wav que cela en est un ^^)

    je n'avais pas poussé plus loin que ca le code, mais pour tout ce qui est des mp3 ou autre format, il faut voir justement au niveau du audioFormat,

    celui de l'api standard ne permet pas de lire les fichier mp3 il me semble, donc allez voir du coté des api externe

    je me rappelle avoir entendu parler de JLayer a un moment, faut creuser de ce coter

  20. #20
    Membre à l'essai
    Inscrit en
    août 2009
    Messages
    30
    Détails du profil
    Informations forums :
    Inscription : août 2009
    Messages : 30
    Points : 11
    Points
    11
    Par défaut
    Bonjour,

    merci de nous avoir répondu,

    le code spécifié au dessus ne permet de lire que des fichier au format wav ( a savoir que ce n'est pas parce que le fichier fini par .wav que cela en est un ^^)
    comment je peux connaitre les vrai fichiers de format wav pour résoudre ce problème ?

    merci bien pour votre aide.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 1
    Dernier message: 18/12/2010, 23h30
  2. Lire un son .wav depuis un serveur ftp
    Par mimi51340 dans le forum Débuter avec Java
    Réponses: 1
    Dernier message: 08/04/2008, 21h32
  3. Réponses: 5
    Dernier message: 05/04/2008, 17h19
  4. Lire un fichier son wav... un peu d' aide svp
    Par pilouface dans le forum C
    Réponses: 10
    Dernier message: 13/05/2006, 16h36
  5. Comment lire une partie du son *.wav
    Par ryosaebafr2000 dans le forum MFC
    Réponses: 5
    Dernier message: 08/06/2005, 16h00

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo