résoudre le problème de UnsupportedAudioFileException

Version imprimable

22/08/2009, 12h31
Sendmi

résoudre le problème de UnsupportedAudioFileException

Bonjour à tous,

j'ai récupéré sur Internet un code source qui permet de lire un fichier wav. mais, malheureusement, il lit seulement un fichier parmis plusieurs et quand aux autres une exception est levée dit:

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)

Un UnsupportedAudioFileException est une exception indiquant que l’opération a échoué car un fichier ne contient pas de données valides d’un type de fichier reconnu et le format.

J’ai téléchargé ces fichiers wav , pourquoi ils ne contiennent pas de données valides.
le fichier lu a la plus petite taille 1,79 ko el le deuxième, par exemple,qui le suit a 9,58 ko. je me demande comment rendre ce code valable pour lire tous les fichiers wav quelque soit leurs taille ?

merci d’avance

le code source est le suivant:

la première classe est:

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
import java.io.File;
 
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
     {
    	 //	recuperation d'un stream de type audio sur le fichier
    	 /** En théorie, pour lire un fichier son, il faut lire le contenu du fichier et 
          *  l'écrire sur la ligne qu'on a créer avec les paramètres qui vont bien.
          *  Pour la capture, on lit depuis la ligne qui va bien et on écrit dans un flux 
          *  sortant */
 
         audioStream = AudioSystem.getAudioInputStream(f);
 
         // recuperation du format de son
         audioFormat = audioStream.getFormat();
         System.out.println(audioFormat); 
 
         // recuperation du son que l'on va stoquer dans un objet de type SourceDataLine
         DataLine.Info info = new DataLine.Info(SourceDataLine.class,audioFormat);
 
         try 
         {
        	 //	recuperation d'une instance de type SourceDataLine
        	 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\n");
     }
 
     /**
      * On arrete le son
      */
     public void stop()
     {
    	 line.stop();
     }
 
     public static void main(String [] args)
     {       
    	 try {
             WavPlayer wp = new WavPlayer(new File("C:\\Documents and Settings\\administrateur\\Bureau\\alarme.wav"));
 
             wp.open();
             wp.play();
             Thread.sleep(100);   // fait patienter 0.1 seconde
            // int i = 0;
            /** while(i <= 10){
                 Thread.sleep(1000);   // fait patienter une seconde
                 System.out.println(i);
                 i++;
             }*/
             wp.stop();
             wp.close();
             System.out.println("\ndebug0");
    	 } 
    	 catch (Exception e)
    	 {
             e.printStackTrace();
         }         
     }
 }

et la deuxième classe est :

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
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;
	 			// cette boucle permet de lire tout le fichier avant de s'arêter 
 
 
	 			while (((bytesRead = WavPlayer.audioStream.read(bytes, 0, bytes.length)) != -1)) 
	 			{
	 				WavPlayer.line.write(bytes, 0, bytesRead);
 
	 			}
	 			for(int i=0;i<29;i++)
	 			{
	 				System.out.print( bytes[i]+" ");	
	 			}	 				
	 	 } 
		 catch (IOException io)
	 	 {
	 		io.printStackTrace();
	 		return;
	 	 }	
	}
}

22/08/2009, 12h54
Sendmi

j'ai essayé de vous envoyer les deux fichiers concernés mais une erreur d'envoi dit que ces fichiers sont non valides, je ne sais pas pourquoi !

pouvez-vous m'aider ?

et merci infiniment
25/08/2009, 16h30
deglingo592003

le format de ton fichier ne doit pas etre bon

ce programme ne lira que les wav,(ton fichier a peu etre été renommée en .wav mais cela n'en fait pas forcement un wav. l'encodage de ton fichier source n'est pas bon)
26/08/2009, 02h53
Sendmi

Bonjour,

merci de m'avoir répondu, j'ai téléchargé pas mal de fichiers wav à travers ce lien:

http://pagesperso-orange.fr/jean-lou...e_son_wav.html

Citation:

le format de ton fichier ne doit pas etre bon

ce programme ne lira que les wav,(ton fichier a peu etre été renommée en .wav mais cela n'en fait pas forcement un wav. l'encodage de ton fichier source n'est pas bon)

un seul fichier parmi 42 autres qui est lu par ce programme (qui est: lazer.wav et j'ai entendu le son). Ces fichiers sont bien des wav et malgré ça, ils ne sont pas lu, je ne sais pas quoi faire et je veux que ce programme lit tout les fichiers wav.
j'ai remarqué que le fichier lu (lazer.wav) a la plus petite taille des autres (2ko), est-ce que c'est un problème de taille ?

pouvez-vous m'aidez ?

merci bien pour votre aide.

pour ce qui est des format de fichier, je n'ai pas eu de problème pour lire d'autre wav

ensuite pour le code utilisé, garde tu exactement le meme code que ci-dessus ?
Code:

1 2 3 4 5 6 7 8 9 10 11 wp.play(); Thread.sleep(100); // fait patienter 0.1 seconde // int i = 0; /** while(i <= 10){ Thread.sleep(1000); // fait patienter une seconde System.out.println(i); i++; }*/ wp.stop(); wp.close();
avec ca tu fait un play dans un thread que tu stop juste après et ensuite tu ferme le tout avec le close();

mais bon si ce n'était que ca tu n'entendrai pas grand chose ! :)

je ne pense pas que la taille influe sur la lecture enfin sans être sûr :)

Bonjour,

oui je garde le même code.

Citation:

avec ca tu fait un play dans un thread que tu stop juste après et ensuite tu ferme le tout avec le close();

mais bon si ce n'était que ca tu n'entendrai pas grand chose !

j'ai fais plusieurs tests sans aucun résultat, qu'est-ce que je peux faire ?

J'ai trouvé cette classe qui fais la même chose mais avec des petites modifications: un seul fichier lu (lazer.wav) et avec les autres la même exception se lève:

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
 
/**
 * File AudioFileReader.java
 * Created on 30 mai 2008
 */
package util;
 
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;
 
/**
 *
 * @author Absil Romain.
 */
public class AudioFileReader
{ 
    public AudioFileReader()
    {
    }
 
    public static void readAudioFile(File file) 
            throws UnsupportedAudioFileException, IOException, 
                LineUnavailableException
    {
        AudioInputStream in = AudioSystem.getAudioInputStream(file);
        AudioInputStream din = null;
        AudioFormat baseFormat = in.getFormat();
        AudioFormat decodedFormat =
                new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
                baseFormat.getSampleRate(),
                16,
                baseFormat.getChannels(),
                baseFormat.getChannels() * 2,
                baseFormat.getSampleRate(),
                false);
        din = AudioSystem.getAudioInputStream(decodedFormat, in);
 
        rawplay(decodedFormat, din);
        in.close();
    }
 
    public static void rawplay(AudioFormat targetFormat, AudioInputStream din)
            throws IOException, LineUnavailableException
    {
        byte[] data = new byte[4096];
        SourceDataLine line = getLine(targetFormat);
        if (line != null)
        {
            // Start
            line.start();
            int nBytesRead = 0, nBytesWritten = 0;
            while (nBytesRead != -1)
            {
                nBytesRead = din.read(data, 0, data.length);
                if (nBytesRead != -1)
                    nBytesWritten = line.write(data, 0, nBytesRead);
            }
 
            for(int i=0;i<29;i++)
				{
					System.out.print( data[i]+" ");	
				}
            // Stop
            line.drain();
            line.stop();
            line.close();
            din.close();
        }
    }
 
    public static SourceDataLine getLine(AudioFormat audioFormat)
            throws LineUnavailableException
    {
        SourceDataLine res = null;
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
        res = (SourceDataLine) AudioSystem.getLine(info);
        res.open(audioFormat);
        return res;
    }
 
    public static void main (String[]args)
    {
    	 try {
 
    		 AudioFileReader pp = new AudioFileReader(); 
    		 pp.readAudioFile(new File("C:\\Documents and Settings\\Zolekha\\Bureau\\alarme.wav"));
             pp.rawplay(null, null);
 
        Thread.sleep(100);   // fait patienter 0.1 seconde
       // int i = 0;
       /** while(i <= 10){
         Thread.sleep(1000);   // fait patienter une seconde
         System.out.println(i);
         i++;
        }*/
 
    System.out.println("\ndebug0");
	 } 
	 catch (Exception e)
	 {
        e.printStackTrace();
    }
 
} 
}

au lieu de PCM_SIGNED j'ai fais PCM_UNSIGNED, à la place de 16 j'ai mis 8 et au lieu de stério j'ai fais mono.

je suis d'accord avec vous la taille n'influe pas sur la lecture parce que j'ai trouvé un autre code qui n'a pas lu le fichier lazer.wav et la même exception est levée. :cry:

merci bien de votre aide.