Java Language
l'audio

Remarques

Lire un fichier audio en boucle

Importations nécessaires:

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

Ce code va créer un clip et le lire en continu une fois démarré:

Clip clip = AudioSystem.getClip();
clip.open(AudioSystem.getAudioInputStream(new URL(filename)));
clip.start();
clip.loop(Clip.LOOP_CONTINUOUSLY);

Obtenir un tableau avec tous les types de fichiers pris en charge:

AudioFileFormat.Type [] audioFileTypes = AudioSystem.getAudioFileTypes();

Jouer un fichier MIDI

Les fichiers MIDI peuvent être lus en utilisant plusieurs classes du package javax.sound.midi . Un Sequencer effectue la lecture du fichier MIDI et plusieurs de ses méthodes peuvent être utilisées pour définir des commandes de lecture telles que le nombre de boucles, le tempo, la mise en sourdine et autres.

La lecture générale des données MIDI peut être effectuée de cette manière:

import java.io.File;
import java.io.IOException;
import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Sequence;
import javax.sound.midi.Sequencer;

public class MidiPlayback {
    public static void main(String[] args) {
        try {
            Sequencer sequencer = MidiSystem.getSequencer(); // Get the default Sequencer
            if (sequencer==null) {
                System.err.println("Sequencer device not supported");
                return;
            } 
            sequencer.open(); // Open device
            // Create sequence, the File must contain MIDI file data.
            Sequence sequence = MidiSystem.getSequence(new File(args[0]));
            sequencer.setSequence(sequence); // load it into sequencer
            sequencer.start();  // start the playback
        } catch (MidiUnavailableException | InvalidMidiDataException | IOException ex) {
            ex.printStackTrace();
        }
    }
}

Pour arrêter la lecture, utilisez:

sequencer.stop(); // Stop the playback

Un séquenceur peut être configuré pour mettre en sourdine une ou plusieurs pistes de la séquence pendant la lecture, de sorte qu'aucun des instruments de la lecture spécifiée ne soit lu. L'exemple suivant définit la première piste de la séquence à mettre en sourdine:

import javax.sound.midi.Track;
// ...

Track[] track = sequence.getTracks();
sequencer.setTrackMute(track[0]);

Un séquenceur peut jouer une séquence à plusieurs reprises si le compte de boucle est donné. Ce qui suit permet au séquenceur de jouer une séquence quatre fois et indéfiniment:

sequencer.setLoopCount(3);
sequencer.setLoopCount(Sequencer.LOOP_CONTINUOUSLY);

Le séquenceur ne doit pas toujours jouer la séquence depuis le début, ni jouer la séquence jusqu'à la fin. Il peut commencer et se terminer à tout moment en spécifiant la coche dans la séquence pour commencer et se terminer. Il est également possible de spécifier manuellement quelle coche dans l'ordre dans lequel le séquenceur doit jouer:

sequencer.setLoopStartPoint(512);
sequencer.setLoopEndPoint(32768);
sequencer.setTickPosition(8192);

Les séquenceurs peuvent également lire un fichier MIDI à un certain tempo, qui peut être contrôlé en spécifiant le tempo en battements par minute (BPM) ou en microsecondes par quart de note (MPQ). Le facteur auquel la séquence est jouée peut également être ajusté.

sequencer.setTempoInBPM(1250f);
sequencer.setTempoInMPQ(4750f);
sequencer.setTempoFactor(1.5f);

Lorsque vous avez fini d'utiliser le Sequencer , rappelez-vous de le fermer

sequencer.close();

Son metal nu

Vous pouvez également aller presque nu-métal lors de la production de son avec Java. Ce code écrira des données binaires brutes dans le tampon audio du système d'exploitation pour générer du son. Il est extrêmement important de comprendre les limites et les calculs nécessaires pour générer un son comme celui-ci. La lecture étant essentiellement instantanée, les calculs doivent être effectués presque en temps réel.

En tant que telle, cette méthode est inutilisable pour un échantillonnage sonore plus compliqué. À cette fin, utiliser des outils spécialisés est la meilleure approche.

La méthode suivante génère et génère directement une onde rectangulaire d'une fréquence donnée dans un volume donné pour une durée donnée.

public void rectangleWave(byte volume, int hertz, int msecs) {
    final SourceDataLine dataLine;
    // 24 kHz x 8bit, single-channel, signed little endian AudioFormat
    AudioFormat af = new AudioFormat(24_000, 8, 1, true, false);
    try {
        dataLine = AudioSystem.getSourceDataLine(af);
        dataLine.open(af, 10_000); // audio buffer size: 10k samples
    } catch (LineUnavailableException e) {
        throw new RuntimeException(e);
    }

    int waveHalf = 24_000 / hertz; // samples for half a period
    byte[] buffer = new byte[waveHalf * 20];
    int samples = msecs * (24_000 / 1000); // 24k (samples / sec) / 1000 (ms/sec) * time(ms)

    dataLine.start(); // starts playback
    int sign = 1;

    for (int i = 0; i < samples; i += buffer.length) {
        for (int j = 0; j < 20; j++) { // generate 10 waves into buffer
            sign *= -1; 
            // fill from the jth wave-half to the j+1th wave-half with volume
            Arrays.fill(buffer, waveHalf * j, waveHalf * (j+1), (byte) (volume * sign));
        }
        dataLine.write(buffer, 0, buffer.length); // 
    }
    dataLine.drain(); // forces buffer drain to hardware
    dataLine.stop();  // ends playback
}

Pour une manière plus différenciée de générer différentes ondes sonores, des calculs sinusaux et éventuellement des tailles d'échantillon plus importantes sont nécessaires. Cela se traduit par un code beaucoup plus complexe et est donc omis ici.

Sortie audio de base

Le bonjour audio! de Java qui joue un fichier audio à partir de stockage local ou Internet ressemble à ceci. Il fonctionne pour les fichiers .wav non compressés et ne doit pas être utilisé pour lire des fichiers MP3 ou compressés.

import java.io.*;
import java.net.URL;
import javax.sound.sampled.*;

public class SoundClipTest {

   // Constructor
   public SoundClipTest() {          
      try {
         // Open an audio input stream.           
          File soundFile = new File("/usr/share/sounds/alsa/Front_Center.wav"); //you could also get the sound file with an URL
          AudioInputStream audioIn = AudioSystem.getAudioInputStream(soundFile); 
          AudioFormat format = audioIn.getFormat();             
         // Get a sound clip resource.
         DataLine.Info info = new DataLine.Info(Clip.class, format);
         Clip clip = (Clip)AudioSystem.getLine(info);
         // Open audio clip and load samples from the audio input stream.
         clip.open(audioIn);
         clip.start();
      } catch (UnsupportedAudioFileException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      } catch (LineUnavailableException e) {
         e.printStackTrace();
      }
   }

   public static void main(String[] args) {
      new SoundClipTest();
   }
}