Java Language
Audio

Uwagi

Odtwórz plik audio zapętlony

Potrzebny import:

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

Ten kod utworzy klip i odtworzy go nieprzerwanie po uruchomieniu:

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

Uzyskaj tablicę ze wszystkimi obsługiwanymi typami plików:

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

Odtwórz plik MIDI

Pliki MIDI można odtwarzać przy użyciu kilku klas z pakietu javax.sound.midi . Sequencer wykonuje odtwarzanie pliku MIDI, a wielu jego metod można używać do ustawiania kontroli odtwarzania, takich jak liczba pętli, tempo, wyciszanie ścieżki i inne.

Ogólne odtwarzanie danych MIDI można wykonać w następujący sposób:

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

Aby zatrzymać odtwarzanie, użyj:

sequencer.stop(); // Stop the playback

Sekwencer można ustawić tak, aby wyciszył jedną lub więcej ścieżek sekwencji podczas odtwarzania, aby żaden z instrumentów nie był odtwarzany w określonym trybie. Poniższy przykład ustawia wyciszenie pierwszego utworu w sekwencji:

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

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

Sekwencer może wielokrotnie odtwarzać sekwencję, jeśli podano liczbę pętli. Poniższe ustawienia ustawiają sekwencer do odtwarzania sekwencji cztery razy i na czas nieokreślony:

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

Sekwencer nie zawsze musi odtwarzać sekwencję od początku, ani nie musi odtwarzać sekwencji do końca. Może zaczynać się i kończyć w dowolnym momencie, zaznaczając tyknięcie w sekwencji, od której zaczyna się i kończy. Możliwe jest również ręczne określenie, z którego tykania w sekwencji sekwencer powinien grać:

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

Sekwencery mogą również odtwarzać plik MIDI w określonym tempie, które można kontrolować, określając tempo w uderzeniach na minutę (BPM) lub mikrosekundach na ćwierćnuta (MPQ). Czynnik, przy którym odtwarzana jest sekwencja, można również dostosować.

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

Po zakończeniu korzystania z Sequencer pamiętaj o jego zamknięciu

sequencer.close();

Nagi metalowy dźwięk

Możesz także przejść prawie od zera, tworząc dźwięk w Javie. Ten kod zapisuje surowe dane binarne w buforze audio systemu operacyjnego w celu wygenerowania dźwięku. Niezwykle ważne jest zrozumienie ograniczeń i niezbędnych obliczeń w celu wygenerowania takiego dźwięku. Ponieważ odtwarzanie jest w zasadzie natychmiastowe, obliczenia należy wykonywać niemal w czasie rzeczywistym.

Jako taka metoda ta nie nadaje się do bardziej skomplikowanego próbkowania dźwięku. Do takich celów lepszym rozwiązaniem jest użycie specjalistycznych narzędzi.

Poniższa metoda generuje i bezpośrednio wysyła falę prostokątną o określonej częstotliwości w danej objętości przez określony czas.

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
}

Aby uzyskać bardziej zróżnicowany sposób generowania różnych fal dźwiękowych, konieczne są obliczenia zatok i ewentualnie większe rozmiary próbek. Powoduje to, że kod jest znacznie bardziej złożony i dlatego jest tutaj pominięty.

Podstawowe wyjście audio

Hello Audio! Java, która odtwarza plik dźwiękowy z pamięci lokalnej lub internetowej wygląda następująco. Działa dla nieskompresowanych plików .wav i nie należy go używać do odtwarzania plików mp3 lub skompresowanych.

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