Java Language
Audio

Osservazioni

Riproduce un file audio in loop

Importazioni necessarie:

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

Questo codice creerà una clip e la riprodurrà continuamente una volta avviata:

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

Ottieni una matrice con tutti i tipi di file supportati:

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

Riproduci un file MIDI

I file MIDI possono essere riprodotti utilizzando diverse classi dal pacchetto javax.sound.midi . Un Sequencer esegue la riproduzione del file MIDI e molti dei suoi metodi possono essere utilizzati per impostare i controlli di riproduzione come il conteggio dei loop, il tempo, il silenziamento della traccia e altri.

La riproduzione generale dei dati MIDI può essere eseguita in questo modo:

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();
        }
    }
}

Per interrompere la riproduzione, utilizzare:

sequencer.stop(); // Stop the playback

Un sequencer può essere impostato per silenziare una o più tracce della sequenza durante la riproduzione in modo che nessuno degli strumenti in quelli specificati suoni. L'esempio seguente imposta la prima traccia nella sequenza da disattivare:

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

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

Un sequencer può riprodurre ripetutamente una sequenza se viene dato il numero di cicli. Quanto segue imposta il sequencer per riprodurre una sequenza quattro volte e indefinitamente:

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

Il sequencer non deve sempre suonare la sequenza dall'inizio, né deve suonare la sequenza fino alla fine. Può iniziare e terminare in qualsiasi momento specificando il segno di spunta nella sequenza da cui iniziare e terminare. È anche possibile specificare manualmente quale tick nella sequenza che il sequencer dovrebbe riprodurre da:

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

I sequencer possono anche riprodurre un file MIDI ad un determinato tempo, che può essere controllato specificando il tempo in battiti al minuto (BPM) o microsecondi per nota da un quarto (MPQ). Anche il fattore con cui viene riprodotta la sequenza può essere regolato.

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

Quando hai finito di usare il Sequencer , ricorda di chiuderlo

sequencer.close();

Suono di metallo nudo

Puoi anche fare quasi bare metal quando produci suoni con java. Questo codice scriverà dati binari grezzi nel buffer audio del sistema operativo per generare suoni. È estremamente importante capire le limitazioni e i calcoli necessari per generare un suono come questo. Poiché la riproduzione è fondamentalmente istantanea, i calcoli devono essere eseguiti quasi in tempo reale.

In quanto tale, questo metodo è inutilizzabile per un campionamento del suono più complicato. Per tali scopi utilizzando strumenti specializzati è l'approccio migliore.

Il seguente metodo genera e genera direttamente un'onda di rettangolo di una determinata frequenza in un dato volume per una data durata.

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
}

Per un modo più differenziato di generare differenti calcoli del seno sonoro e possibilmente dimensioni del campione più grandi sono necessarie. Ciò si traduce in codice significativamente più complesso ed è quindi omesso qui.

Uscita audio di base

Hello Audio! di Java che riproduce un file audio dall'archivio locale o su Internet, appare come segue. Funziona con file wav non compressi e non deve essere utilizzato per riprodurre file mp3 o compressi.

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();
   }
}