Java Language
Audio

Anmärkningar

Spela en ljudfil Looped

Nödvändig import:

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

Den här koden skapar ett klipp och spelar upp det kontinuerligt när det börjat:

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

Skaffa en matris med alla filtyper som stöds:

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

Spela en MIDI-fil

MIDI-filer kan spelas med flera klasser från paketet javax.sound.midi . En Sequencer utför uppspelning av MIDI-filen, och många av dess metoder kan användas för att ställa in uppspelningskontroller såsom loopantal, tempo, spårmutning och andra.

Allmän uppspelning av MIDI-data kan göras på detta sätt:

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

För att stoppa uppspelningen använder du:

sequencer.stop(); // Stop the playback

En sequencer kan ställas in för att stänga av ett eller flera av sekvensens spår under uppspelning så att inget av instrumenten i den angivna uppspelningen. Följande exempel ställer in det första spåret i sekvensen som ska dämpas:

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

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

En sequencer kan spela en sekvens upprepade gånger om loopantalet ges. Följande ställer in sequenser för att spela en sekvens fyra gånger och på obestämd tid:

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

Sekvenseraren behöver inte alltid spela sekvensen från början, och behöver inte heller spela sekvensen till slutet. Det kan börja och sluta när som helst genom att ange fästet i sekvensen som ska startas och slutas vid. Det är också möjligt att manuellt ange vilken kryss i sekvensen som sequenser ska spela från:

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

Sekvenser kan också spela en MIDI-fil i ett visst tempo, som kan kontrolleras genom att ange tempot i beats per minute (BPM) eller mikrosekunder per quarter note (MPQ). Faktorn vid vilken sekvensen spelas kan också justeras.

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

När du är klar med Sequencer , kom ihåg att stänga den

sequencer.close();

Kala metallljud

Du kan också gå nästan bara metall när du producerar ljud med java. Denna kod kommer att skriva rå binär data till OS-ljudbufferten för att generera ljud. Det är oerhört viktigt att förstå begränsningarna och nödvändiga beräkningarna för att generera ljud som detta. Eftersom uppspelningen i princip är omedelbar måste beräkningar utföras i nästan realtid.

Som sådan är denna metod oanvändbar för mer komplicerad ljudsampling. För sådana ändamål är det bättre att använda specialiserade verktyg.

Följande metod genererar och matar ut en rektangelvåg med en given frekvens i en given volym under en viss tid.

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
}

För ett mer differentierat sätt att generera olika ljudvågor är sinusberäkningar och eventuellt större provstorlekar nödvändiga. Detta resulterar i betydligt mer komplex kod och utelämnas följaktligen här.

Grundläggande ljudutgång

Hejljudet! av Java som spelar en ljudfil från lokal lagring eller internetlagring ser ut enligt följande. Det fungerar för okomprimerade .wav-filer och bör inte användas för att spela mp3- eller komprimerade filer.

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