Vous jouez .mp3 et .wav en Java?

Comment puis-je lire .mp3un .wavfichier et un fichier dans mon application Java? J'utilise Swing. J'ai essayé de chercher sur Internet, quelque chose comme cet exemple:

public void playSound() {
    try {
        AudioInputStream audioInputStream = AudioSystem.getAudioInputStream(new File("D:/MusicPlayer/fml.mp3").getAbsoluteFile());
        Clip clip = AudioSystem.getClip();
        clip.open(audioInputStream);
        clip.start();
    } catch(Exception ex) {
        System.out.println("Error with playing sound.");
        ex.printStackTrace();
    }
}

Mais, cela ne lira que les .wavfichiers.

De même:

http://www.javaworld.com/javaworld/javatips/jw-javatip24.html

Je veux pouvoir lire les .mp3fichiers et les .wavfichiers avec la même méthode.

Java FX a Mediaet MediaPlayerclasses qui liront les fichiers mp3.

Exemple de code:

String bip = "bip.mp3";
Media hit = new Media(new File(bip).toURI().toString());
MediaPlayer mediaPlayer = new MediaPlayer(hit);
mediaPlayer.play();

Vous aurez besoin des instructions d'importation suivantes:

import java.io.File;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;

J'ai écrit un pur lecteur mp3 java: mp3transform .

vous ne pouvez jouer .wav qu'avec l'API java:

import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;

code:

AudioInputStream audioIn = AudioSystem.getAudioInputStream(MyClazz.class.getResource("music.wav"));
Clip clip = AudioSystem.getClip();
clip.open(audioIn);
clip.start();

Et jouez .mp3 avec jLayer

Cela fait un moment que je ne l'ai pas utilisé, mais JavaLayer est idéal pour la lecture MP3

Utilisation de l'API javax.sound standard, une seule dépendance Maven, complètement Open Source ( Java 7 requis):

pom.xml

 <!-- 
    We have to explicitly instruct Maven to use tritonus-share 0.3.7-2 
    and NOT 0.3.7-1, otherwise vorbisspi won't work.
   -->
<dependency>
  <groupId>com.googlecode.soundlibs</groupId>
  <artifactId>tritonus-share</artifactId>
  <version>0.3.7-2</version>
</dependency>
<dependency>
  <groupId>com.googlecode.soundlibs</groupId>
  <artifactId>mp3spi</artifactId>
  <version>1.9.5-1</version>
</dependency>
<dependency>
  <groupId>com.googlecode.soundlibs</groupId>
  <artifactId>vorbisspi</artifactId>
  <version>1.0.3-1</version>
</dependency>

Code

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.Info;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;

import static javax.sound.sampled.AudioSystem.getAudioInputStream;
import static javax.sound.sampled.AudioFormat.Encoding.PCM_SIGNED;

public class AudioFilePlayer {

    public static void main(String[] args) {
        final AudioFilePlayer player = new AudioFilePlayer ();
        player.play("something.mp3");
        player.play("something.ogg");
    }

    public void play(String filePath) {
        final File file = new File(filePath);

        try (final AudioInputStream in = getAudioInputStream(file)) {

            final AudioFormat outFormat = getOutFormat(in.getFormat());
            final Info info = new Info(SourceDataLine.class, outFormat);

            try (final SourceDataLine line =
                     (SourceDataLine) AudioSystem.getLine(info)) {

                if (line != null) {
                    line.open(outFormat);
                    line.start();
                    stream(getAudioInputStream(outFormat, in), line);
                    line.drain();
                    line.stop();
                }
            }

        } catch (UnsupportedAudioFileException 
               | LineUnavailableException 
               | IOException e) {
            throw new IllegalStateException(e);
        }
    }

    private AudioFormat getOutFormat(AudioFormat inFormat) {
        final int ch = inFormat.getChannels();

        final float rate = inFormat.getSampleRate();
        return new AudioFormat(PCM_SIGNED, rate, 16, ch, ch * 2, rate, false);
    }

    private void stream(AudioInputStream in, SourceDataLine line) 
        throws IOException {
        final byte[] buffer = new byte[4096];
        for (int n = 0; n != -1; n = in.read(buffer, 0, buffer.length)) {
            line.write(buffer, 0, n);
        }
    }
}

Références:

• http://odoepner.wordpress.com/2013/07/19/play-mp3-using-javax-sound-sampled-api-and-mp3spi/

Je recommanderais d'utiliser le BasicPlayerAPI. C'est open source, très simple et ne nécessite pas JavaFX. http://www.javazoom.net/jlgui/api.html

Après avoir téléchargé et extrait le fichier zip, il faut ajouter les fichiers jar suivants au chemin de construction du projet:

• basicplayer3.0.jar
• tous les jars du répertoire lib (dans BasicPlayer3.0)

Voici un exemple d'utilisation minimaliste:

String songName = "HungryKidsofHungary-ScatteredDiamonds.mp3";
String pathToMp3 = System.getProperty("user.dir") +"/"+ songName;
BasicPlayer player = new BasicPlayer();
try {
    player.open(new URL("file:///" + pathToMp3));
    player.play();
} catch (BasicPlayerException | MalformedURLException e) {
    e.printStackTrace();
}

Importations requises:

import java.net.MalformedURLException;
import java.net.URL;
import javazoom.jlgui.basicplayer.BasicPlayer;
import javazoom.jlgui.basicplayer.BasicPlayerException;

C'est tout ce dont vous avez besoin pour commencer à jouer de la musique. Le lecteur démarre et gère son propre fil de lecture et propose lecture, pause, reprise, arrêt et recherche .

Pour une utilisation plus avancée, vous pouvez jeter un œil au lecteur de musique jlGui. C'est un clone WinAmp open source: http://www.javazoom.net/jlgui/jlgui.html

La première classe à examiner serait PlayerUI (dans le package javazoom.jlgui.player.amp). Il démontre assez bien les fonctionnalités avancées du BasicPlayer.

Le moyen le plus simple que j'ai trouvé était de télécharger le fichier jar JLayer à partir de http://www.javazoom.net/javalayer/sources.html et de l'ajouter à la bibliothèque Jar http://www.wikihow.com/Add-JARs- vers-Project-Build-Paths-in-Eclipse-% 28Java% 29

Voici le code de la classe

public class SimplePlayer {

    public SimplePlayer(){

        try{

             FileInputStream fis = new FileInputStream("File location.");
             Player playMP3 = new Player(fis);

             playMP3.play();

        }  catch(Exception e){
             System.out.println(e);
           }
    } 
}

et voici les importations

import javazoom.jl.player.*;
import java.io.FileInputStream;

Pour donner aux lecteurs une autre alternative, je suggère la bibliothèque JACo MP3 Player, un lecteur mp3 java multiplateforme.

Fonctionnalités:

• très faible utilisation du processeur (~ 2%)
• incroyable petite bibliothèque (~ 90 Ko)
• n'a pas besoin de JMF (Java Media Framework)
• facile à intégrer dans n'importe quelle application
• facile à intégrer dans n'importe quelle page Web (sous forme d'applet).

Pour une liste complète de ses méthodes et attributs, vous pouvez consulter sa documentation ici .

Exemple de code:

import jaco.mp3.player.MP3Player;
import java.io.File;

public class Example1 {
  public static void main(String[] args) {
    new MP3Player(new File("test.mp3")).play();
  }
}

Pour plus de détails, j'ai créé un tutoriel simple ici qui comprend un code source téléchargeable.

Utilisation du décodeur / lecteur / convertisseur MP3 Dépendance Maven.

import javazoom.jl.decoder.JavaLayerException;
import javazoom.jl.player.Player;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class PlayAudio{

public static void main(String[] args) throws FileNotFoundException {

    try {
        FileInputStream fileInputStream = new FileInputStream("mp.mp3");
        Player player = new Player((fileInputStream));
        player.play();
        System.out.println("Song is playing");
        while(true){
            System.out.println(player.getPosition());
        }
    }catch (Exception e){
        System.out.println(e);
    }

  }

}

Vous devez d'abord installer JMF ( télécharger en utilisant ce lien )

File f = new File("D:/Songs/preview.mp3");
MediaLocator ml = new MediaLocator(f.toURL());
Player p = Manager.createPlayer(ml);
p.start();

n'oubliez pas d'ajouter les fichiers jar JMF

Faites une recherche sur freshmeat.net pour la bibliothèque JAVE (signifie Java Audio Video Encoder) (lien ici ). C'est une bibliothèque pour ce genre de choses. Je ne sais pas si Java a une fonction mp3 native.

Vous devrez probablement encapsuler la fonction mp3 et la fonction wav ensemble, en utilisant l'héritage et une simple fonction wrapper, si vous voulez qu'une méthode exécute les deux types de fichiers.

Pour ajouter la prise en charge de la lecture MP3 à Java Sound, ajoutez le mp3plugin.jarfichier JMF au chemin d'accès aux classes d'exécution de l'application.

Notez que la Clipclasse a des limitations de mémoire qui la rendent inadaptée pour plus de quelques secondes de son de haute qualité.

J'ai d'autres méthodes pour cela, la première est:

public static void playAudio(String filePath){

    try{
        InputStream mus = new FileInputStream(new File(filePath));
        AudioStream aud = new AudioStream(mus);
    }catch(Exception e){
        JOptionPane.showMessageDialig(null, "You have an Error");
    }

Et le second est:

try{
    JFXPanel x = JFXPanel();
    String u = new File("021.mp3").toURI().toString();
    new MediaPlayer(new Media(u)).play();
} catch(Exception e){
    JOPtionPane.showMessageDialog(null, e);
}

Et si nous voulons faire une boucle sur cet audio, nous utilisons cette méthode.

try{
    AudioData d = new AudioStream(new FileInputStream(filePath)).getData();
    ContinuousAudioDataStream s = new ContinuousAudioDataStream(d);
    AudioPlayer.player.start(s);
} catch(Exception ex){
    JOPtionPane.showMessageDialog(null, ex);
}

si nous voulons arrêter cette boucle, nous ajoutons ces libreries dans l'essai:

AudioPlayer.player.stop(s);

pour cette troisième méthode, nous ajoutons les importations suivantes:

import java.io.FileInputStream;
import sun.audio.AudioData;
import sun.audio.AudioStream;
import sun.audio.ContinuousAudioDataStream;

Utilisez cette bibliothèque: import sun.audio. *;

public void Sound(String Path){
    try{
        InputStream in = new FileInputStream(new File(Path));
        AudioStream audios = new AudioStream(in);
        AudioPlayer.player.start(audios);
    }
    catch(Exception e){}
}