Java Language
Audio

Observaciones

Reproducir un archivo de audio en bucle

Importaciones necesarias:

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

Este código creará un clip y lo reproducirá continuamente una vez iniciado:

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

Obtenga una matriz con todos los tipos de archivos compatibles:

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

Reproducir un archivo MIDI

Los archivos MIDI se pueden reproducir utilizando varias clases del paquete javax.sound.midi . Un Sequencer realiza la reproducción del archivo MIDI, y muchos de sus métodos pueden usarse para configurar controles de reproducción como el conteo de bucles, el tempo, el silenciamiento de pistas y otros.

La reproducción general de datos MIDI se puede hacer de esta manera:

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

Para detener la reproducción usa:

sequencer.stop(); // Stop the playback

Se puede configurar un secuenciador para silenciar una o más de las pistas de la secuencia durante la reproducción, por lo que ninguno de los instrumentos en esos juegos especificados. El siguiente ejemplo configura la primera pista en la secuencia a silenciar:

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

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

Un secuenciador puede reproducir una secuencia repetidamente si se da el recuento de bucles. A continuación se establece el secuenciador para reproducir una secuencia cuatro veces e indefinidamente:

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

El secuenciador no siempre tiene que reproducir la secuencia desde el principio, ni tiene que reproducir la secuencia hasta el final. Puede comenzar y terminar en cualquier punto especificando la marca en la secuencia para comenzar y terminar en. También es posible especificar manualmente qué tic en la secuencia debe jugar el secuenciador desde:

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

Los secuenciadores también pueden reproducir un archivo MIDI a un determinado tempo, que puede controlarse especificando el tempo en tiempos por minuto (BPM) o microsegundos por cuarto de nota (MPQ). El factor en el que se reproduce la secuencia también se puede ajustar.

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

Cuando termine de usar el Sequencer , recuerde cerrarla

sequencer.close();

Sonido de metal desnudo

También puedes usar el metal casi al desnudo al producir sonido con java. Este código escribirá datos binarios sin procesar en el búfer de audio del sistema operativo para generar sonido. Es extremadamente importante comprender las limitaciones y los cálculos necesarios para generar un sonido como este. Dado que la reproducción es básicamente instantánea, los cálculos deben realizarse casi en tiempo real.

Como tal, este método es inutilizable para un muestreo de sonido más complicado. Para tales fines, el uso de herramientas especializadas es el mejor enfoque.

El siguiente método genera y emite directamente una onda rectangular de una frecuencia dada en un volumen dado para una duración determinada.

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
}

Para una forma más diferenciada de generar diferentes ondas de sonido, son necesarios cálculos sinusales y posiblemente tamaños de muestra más grandes. Esto da como resultado un código significativamente más complejo y, por consiguiente, se omite aquí.

Salida de audio básica

El Hola Audio! de Java que reproduce un archivo de sonido desde el almacenamiento local o de Internet tiene el siguiente aspecto. Funciona para archivos .wav sin comprimir y no debe usarse para reproducir archivos mp3 o comprimidos.

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