Java Language
audio

Opmerkingen

Speel een audiobestand in een lus af

Nodige invoer:

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

Deze code maakt een clip en speelt deze continu af zodra deze is gestart:

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

Download een array met alle ondersteunde bestandstypen:

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

Speel een MIDI-bestand

MIDI-bestanden kunnen worden afgespeeld met behulp van verschillende klassen uit het pakket javax.sound.midi . Een Sequencer voert het afspelen van het MIDI-bestand uit, en veel van zijn methoden kunnen worden gebruikt om afspeelregelaars in te stellen, zoals het aantal lussen, het tempo, het dempen van nummers en andere.

Algemeen afspelen van MIDI-gegevens kan op deze manier worden gedaan:

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

Gebruik het volgende om het afspelen te stoppen:

sequencer.stop(); // Stop the playback

Een sequencer kan worden ingesteld om een of meer tracks van de reeks tijdens het afspelen te dempen, dus geen van de instrumenten in het opgegeven spel. In het volgende voorbeeld wordt het eerste nummer in de reeks ingesteld dat moet worden gedempt:

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

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

Een sequencer kan een reeks herhaaldelijk spelen als het aantal lussen wordt aangegeven. Het volgende stelt de sequencer in om een reeks vier keer en voor onbepaalde tijd te spelen:

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

De sequencer hoeft de reeks niet altijd vanaf het begin af te spelen, noch hoeft de reeks tot het einde te worden afgespeeld. Het kan op elk gewenst moment beginnen en eindigen door het vinkje in de reeks op te geven om te beginnen en eindigen. Het is ook mogelijk om handmatig aan te geven uit welk vinkje in de reeks de sequencer moet spelen:

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

Sequencers kunnen ook een MIDI-bestand in een bepaald tempo afspelen, dat kan worden bestuurd door het tempo op te geven in beats per minuut (BPM) of microseconden per kwartnoot (MPQ). De factor waarmee de reeks wordt gespeeld, kan ook worden aangepast.

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

Wanneer u klaar bent met het gebruik van de Sequencer , moet u eraan denken om deze te sluiten

sequencer.close();

Blank metaalgeluid

Je kunt ook bijna bare-metal gaan wanneer je geluid produceert met Java. Deze code schrijft onbewerkte binaire gegevens in de OS-audiobuffer om geluid te genereren. Het is uiterst belangrijk om de beperkingen en noodzakelijke berekeningen te begrijpen om zo'n geluid te genereren. Omdat het afspelen vrijwel onmiddellijk gebeurt, moeten berekeningen vrijwel realtime worden uitgevoerd.

Als zodanig is deze methode onbruikbaar voor meer gecompliceerde geluidssampling. Voor dergelijke doeleinden is het gebruik van gespecialiseerde tools de betere aanpak.

De volgende methode genereert en geeft direct een rechthoekgolf van een bepaalde frequentie in een bepaald volume gedurende een bepaalde duur.

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
}

Voor een meer gedifferentieerde manier om verschillende geluidsgolven te genereren, zijn sinusberekeningen en mogelijk grotere steekproefgroottes nodig. Dit resulteert in een aanzienlijk complexere code en wordt daarom hier weggelaten.

Standaard audio-uitgang

De Hallo Audio! van Java dat een geluidsbestand afspeelt van lokale of internetopslag ziet er als volgt uit. Het werkt voor niet-gecomprimeerde .wav-bestanden en mag niet worden gebruikt voor het afspelen van mp3- of gecomprimeerde bestanden.

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