X-Git-Url: https://git.pterodactylus.net/?p=sonitus.git;a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fsonitus%2Fdata%2Fsink%2FAudioSink.java;h=6cace627ec200a4fb3e8e05eb73e80f2a30bbaf6;hp=611dcd97219a92b9b49d3eac929de5be661691a9;hb=633a841142f978235ed9f745b6ba16c278963e62;hpb=b61d311f6fd16ccf65decf3b29e9b06bb58406cd diff --git a/src/main/java/net/pterodactylus/sonitus/data/sink/AudioSink.java b/src/main/java/net/pterodactylus/sonitus/data/sink/AudioSink.java index 611dcd9..6cace62 100644 --- a/src/main/java/net/pterodactylus/sonitus/data/sink/AudioSink.java +++ b/src/main/java/net/pterodactylus/sonitus/data/sink/AudioSink.java @@ -17,34 +17,40 @@ package net.pterodactylus.sonitus.data.sink; +import static javax.sound.sampled.BooleanControl.Type.MUTE; import static javax.sound.sampled.FloatControl.Type.VOLUME; import java.io.IOException; +import java.io.OutputStream; import java.util.Arrays; import java.util.List; import java.util.logging.Logger; import javax.sound.sampled.AudioFormat; import javax.sound.sampled.AudioSystem; +import javax.sound.sampled.BooleanControl; +import javax.sound.sampled.Control; +import javax.sound.sampled.DataLine; import javax.sound.sampled.FloatControl; import javax.sound.sampled.LineUnavailableException; import javax.sound.sampled.SourceDataLine; +import net.pterodactylus.sonitus.data.AbstractFilter; import net.pterodactylus.sonitus.data.Controller; +import net.pterodactylus.sonitus.data.Filter; import net.pterodactylus.sonitus.data.Metadata; -import net.pterodactylus.sonitus.data.Sink; -import net.pterodactylus.sonitus.data.Source; import net.pterodactylus.sonitus.data.controller.Fader; import net.pterodactylus.sonitus.data.controller.Switch; +import net.pterodactylus.sonitus.io.IntegralWriteOutputStream; import com.google.common.base.Preconditions; /** - * {@link Sink} implementation that uses the JDK’s {@link AudioSystem} to play - * all {@link Source}s. + * {@link Filter} implementation that uses the JDK’s {@link AudioSystem} to play + * all the audio signal. * * @author David ‘Bombe’ Roden */ -public class AudioSink implements Sink { +public class AudioSink extends AbstractFilter { /** The logger. */ private static final Logger logger = Logger.getLogger(AudioSink.class.getName()); @@ -55,46 +61,80 @@ public class AudioSink implements Sink { /** The “mute” switch. */ private final Switch muteSwitch; - /** The current metadata. */ - private Metadata metadata; - /** The audio output. */ private SourceDataLine sourceDataLine; + /** A buffered output stream to ensure correct writing to the source data line. */ + private OutputStream sourceDataLineOutputStream = new IntegralWriteOutputStream(new OutputStream() { + + @Override + public void write(int b) throws IOException { + } + + @Override + public void write(byte[] b) throws IOException { + write(b, 0, b.length); + } + + @Override + public void write(byte[] b, int off, int len) throws IOException { + if (sourceDataLine != null) { + sourceDataLine.write(b, off, len); + } + } + }, 1024); + /** Creates a new audio sink. */ public AudioSink() { - super(); + super("Audio Output"); volumeFader = new Fader("Volume") { @Override protected void valueSet(Double value) { - if (sourceDataLine != null) { - FloatControl volumeControl = (FloatControl) sourceDataLine.getControl(VOLUME); - volumeControl.setValue((float) (value * volumeControl.getMaximum())); + /* search for preferred volume control. */ + FloatControl volumeControl = getVolumeControl(sourceDataLine); + if (volumeControl == null) { + /* could not find volume control! */ + return; } + + volumeControl.setValue((float) (value * volumeControl.getMaximum())); } }; muteSwitch = new Switch("Mute") { + /** The previous value in case we have to emulate the mute control. */ private float previousValue; @Override protected void valueSet(Boolean value) { - if (sourceDataLine != null) { - FloatControl volumeControl = (FloatControl) sourceDataLine.getControl(VOLUME); - if (value) { - previousValue = volumeControl.getValue(); - volumeControl.setValue(0); - } else { - volumeControl.setValue(previousValue); - } + /* search for mute control. */ + BooleanControl muteControl = getMuteControl(sourceDataLine); + if (muteControl != null) { + muteControl.setValue(value); + return; + } + + /* could not find mute control, use volume control! */ + FloatControl volumeControl = getVolumeControl(sourceDataLine); + if (volumeControl == null) { + /* no volume control, either? */ + return; + } + + if (value) { + previousValue = volumeControl.getValue(); + volumeControl.setValue(0); + } else { + volumeControl.setValue(previousValue); } } + }; } // - // CONTROLLED METHODS + // FILTER METHODS // @Override @@ -102,20 +142,19 @@ public class AudioSink implements Sink { return Arrays.>asList(volumeFader, muteSwitch); } - // - // SINK METHODS - // - @Override public void open(Metadata metadata) throws IOException { Preconditions.checkArgument(metadata.encoding().equalsIgnoreCase("PCM"), "source must be PCM-encoded"); + super.open(metadata); AudioFormat audioFormat = new AudioFormat(metadata.frequency(), 16, metadata.channels(), true, false); try { sourceDataLine = AudioSystem.getSourceDataLine(audioFormat); sourceDataLine.open(audioFormat); sourceDataLine.start(); + metadataUpdated(metadata); } catch (LineUnavailableException e) { /* TODO */ + sourceDataLine = null; throw new IOException(e); } } @@ -128,13 +167,68 @@ public class AudioSink implements Sink { @Override public void metadataUpdated(Metadata metadata) { - logger.info(String.format("Now playing %s.", metadata)); + super.metadataUpdated(metadata); + logger.fine(String.format("Now playing %s.", metadata)); } @Override - public void process(byte[] buffer) { - sourceDataLine.write(buffer, 0, buffer.length); + public void process(byte[] buffer) throws IOException { + sourceDataLineOutputStream.write(buffer); + super.process(buffer); logger.finest(String.format("AudioSink: Wrote %d Bytes.", buffer.length)); } + // + // PRIVATE METHODS + // + + /** + * Returns the {@link FloatControl.Type#VOLUME} control. + * + * @param dataLine + * The data line to search for the control + * @return The control, or {@code null} if no volume control could be found + */ + private static FloatControl getVolumeControl(DataLine dataLine) { + return getControl(dataLine, VOLUME, FloatControl.class); + } + + /** + * Returns the {@link BooleanControl.Type#MUTE} control. + * + * @param dataLine + * The data line to search for the control + * @return The control, or {@code null} if no mute control could be found + */ + private static BooleanControl getMuteControl(DataLine dataLine) { + return getControl(dataLine, MUTE, BooleanControl.class); + } + + /** + * Searches the given data line for a control of the given type and returns it. + * If the given data line is {@code null}, {@code null} is returned. + * + * @param dataLine + * The data line to search for a control + * @param controlType + * The type of the control to search + * @param controlClass + * The class of the control + * @param + * The class of the control + * @return The control, or {@code null} if no control could be found + */ + private static T getControl(DataLine dataLine, Control.Type controlType, Class controlClass) { + if (dataLine == null) { + return null; + } + Control[] controls = dataLine.getControls(); + for (Control control : controls) { + if (control.getType().equals(controlType)) { + return (T) control; + } + } + return null; + } + }