AudioPlayer.java

Go to the documentation of this file.

package com.neuronrobotics.bowlerstudio;
 
import java.io.File;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
 
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.FloatControl;
import javax.sound.sampled.LineListener;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;
 
import marytts.util.data.audio.MonoAudioInputStream;
import marytts.util.data.audio.StereoAudioInputStream;
 
public class AudioPlayer extends Thread {
 
    public static final int MONO = 0;
    public static final int STEREO = 3;
    public static final int LEFT_ONLY = 1;
    public static final int RIGHT_ONLY = 2;
    private AudioInputStream ais;
    private LineListener lineListener;
    private ISpeakingProgress speakProgress;
    private SourceDataLine line;
    private int outputMode;
 
    private Status status = Status.WAITING;
    private boolean exitRequested = false;
    private float gain = 1.0f;
    private String TTSString;
    private static double threshhold = 600 / 65535.0;
    private static double lowerThreshhold = 100 / 65535.0;;
    private static int integralDepth = 30;
    private static double integralGain = 1.0;
    private static double derivitiveGain = 1.0;
    private static IAudioProcessingLambda lambda = new IAudioProcessingLambda() {
        // code reference from the face application
        // https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/AdaVoice/adavoice_face/adavoice_face.ino
        int xfadeDistance = 16;
        double[] samples = new double[xfadeDistance];
        int xfadeIndex = 0;
        boolean stare = true;
 
        @Override
        public AudioStatus update(AudioStatus currentStatus, double amplitudeUnitVector, double currentRollingAverage,
                double currentDerivitiveTerm, double percent) {
            if (stare) {
                stare = false;
                for (int i = 0; i < xfadeDistance; i++) {
                    samples[i] = currentRollingAverage;
                }
            }
            double index = samples[xfadeIndex];
            samples[xfadeIndex] = currentRollingAverage;
            xfadeIndex++;
            if (xfadeIndex == xfadeDistance) {
                xfadeIndex = 0;
            }
            double val = (currentRollingAverage + index) / 2 * currentDerivitiveTerm;
            switch (currentStatus) {
            case B_KST_SOUNDS:
                if (val > AudioPlayer.getThreshhold()) {
                    currentStatus = AudioStatus.D_AA_SOUNDS;
                }
                break;
            case G_F_V_SOUNDS:
                if (val < AudioPlayer.getLowerThreshhold()) {
                    currentStatus = AudioStatus.X_NO_SOUND;
                }
                break;
            case X_NO_SOUND:
                if (val > AudioPlayer.getThreshhold()) {
                    currentStatus = AudioStatus.B_KST_SOUNDS;
                }
                break;
            case D_AA_SOUNDS:
                if (val < AudioPlayer.getLowerThreshhold()) {
                    currentStatus = AudioStatus.G_F_V_SOUNDS;
                }
                break;
            default:
                break;
            }
            return currentStatus;
        }
 
        @Override
        public AudioInputStream startProcessing(AudioInputStream ais, String TTSString) {
            stare = true;
            return ais;
        }
    };
 
    public enum Status {
        WAITING,
        PLAYING;
    }
 
    public AudioPlayer(String tts) {
        TTSString=tts;
    }
 
    public AudioPlayer(File audioFile) throws IOException, UnsupportedAudioFileException {
        this.ais = AudioSystem.getAudioInputStream(audioFile);
    }
 
    public AudioPlayer(AudioInputStream ais) {
        this.ais = ais;
    }
 
    public AudioPlayer(File audioFile, LineListener lineListener) throws IOException, UnsupportedAudioFileException {
        this.ais = AudioSystem.getAudioInputStream(audioFile);
        this.lineListener = lineListener;
    }
 
    public AudioPlayer(AudioInputStream ais, LineListener lineListener) {
        this.ais = ais;
        this.lineListener = lineListener;
    }
 
    public AudioPlayer(File audioFile, SourceDataLine line, LineListener lineListener)
            throws IOException, UnsupportedAudioFileException {
        this.ais = AudioSystem.getAudioInputStream(audioFile);
        this.setLine(line);
        this.lineListener = lineListener;
    }
 
    public AudioPlayer(AudioInputStream ais, SourceDataLine line, LineListener lineListener) {
        this.ais = ais;
        this.setLine(line);
        this.lineListener = lineListener;
    }
 
    public AudioPlayer(File audioFile, SourceDataLine line, LineListener lineListener, int outputMode)
            throws IOException, UnsupportedAudioFileException {
        this.ais = AudioSystem.getAudioInputStream(audioFile);
        this.setLine(line);
        this.lineListener = lineListener;
        this.outputMode = outputMode;
    }
 
    public AudioPlayer(AudioInputStream ais, SourceDataLine line, LineListener lineListener, int outputMode) {
        this.ais = ais;
        this.setLine(line);
        this.lineListener = lineListener;
        this.outputMode = outputMode;
    }
 
    public void setAudio(AudioInputStream audio) {
        if (status == Status.PLAYING) {
            throw new IllegalStateException("Cannot set audio while playing");
        }
        this.ais = audio;
    }
 
    public void cancel() {
        if (getLine() != null) {
            getLine().stop();
        }
        exitRequested = true;
    }
 
    public SourceDataLine getLine() {
        return line;
    }
 
    public float getGainValue() {
        return gain;
    }
 
    public void setGain(float fGain) {
 
        // if (line != null)
        // System.out.println(((FloatControl)
        // line.getControl(FloatControl.Type.MASTER_GAIN)).getValue())
 
        // Set the value
        gain = fGain;
 
        // Better type
        if (getLine() != null && getLine().isControlSupported(FloatControl.Type.MASTER_GAIN))
            ((FloatControl) getLine().getControl(FloatControl.Type.MASTER_GAIN))
                    .setValue((float) (20 * Math.log10(fGain <= 0.0 ? 0.0000 : fGain)));
        // OR (Math.log(fGain == 0.0 ? 0.0000 : fGain) / Math.log(10.0))
 
        // if (line != null)
        // System.out.println(((FloatControl)
        // line.getControl(FloatControl.Type.MASTER_GAIN)).getValue())
    }
 
    @Override
    public void run() {
 
        status = Status.PLAYING;
        ais = lambda.startProcessing(ais,TTSString);
        AudioFormat audioFormat = ais.getFormat();
        if (audioFormat.getChannels() == 1) {
            if (outputMode != 0) {
                ais = new StereoAudioInputStream(ais, outputMode);
                audioFormat = ais.getFormat();
            }
        } else {
            assert audioFormat.getChannels() == 2 : "Unexpected number of channels: " + audioFormat.getChannels();
            if (outputMode == 0) {
                ais = new MonoAudioInputStream(ais);
            } else if (outputMode == 1 || outputMode == 2) {
                ais = new StereoAudioInputStream(ais, outputMode);
            } else {
                assert outputMode == 3 : "Unexpected output mode: " + outputMode;
            }
        }
 
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
 
        try {
            if (getLine() == null) {
                boolean bIsSupportedDirectly = AudioSystem.isLineSupported(info);
                if (!bIsSupportedDirectly) {
                    AudioFormat sourceFormat = audioFormat;
                    AudioFormat targetFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
                            sourceFormat.getSampleRate(), sourceFormat.getSampleSizeInBits(),
                            sourceFormat.getChannels(),
                            sourceFormat.getChannels() * (sourceFormat.getSampleSizeInBits() / 8),
                            sourceFormat.getSampleRate(), sourceFormat.isBigEndian());
 
                    ais = AudioSystem.getAudioInputStream(targetFormat, ais);
                    audioFormat = ais.getFormat();
                }
                info = new DataLine.Info(SourceDataLine.class, audioFormat);
                setLine((SourceDataLine) AudioSystem.getLine(info));
            }
            if (lineListener != null) {
                getLine().addLineListener(lineListener);
            }
            getLine().open(audioFormat);
        } catch (Exception ex) {
            Logger.getLogger(getClass().getName()).log(Level.WARNING, null, ex);
            return;
        }
 
        getLine().start();
        setGain(getGainValue());
 
        int nRead = 0;
        byte[] abData = new byte[6553];
        int total = 0;
        AudioStatus status = AudioStatus.X_NO_SOUND;
        int integralIndex = 0;
        double integralTotal = 0;
        double[] buffer = null;
        Double previousValue = null;
        try {
            while ((nRead != -1) && (!exitRequested) && (!Thread.interrupted())) {
//          try {
//              Thread.sleep(0,1);
//          } catch (InterruptedException e) {
//              break;
//          }
                try {
                    nRead = ais.read(abData, 0, abData.length);
                } catch (IOException ex) {
                    Logger.getLogger(getClass().getName()).log(Level.WARNING, null, ex);
                }
                int lastIndex = 0;
                int amountToRead = nRead;
 
                if (nRead >= 0) {
 
                    if (speakProgress != null) {
 
                        for (int i = 0; i < nRead - 1; i += 2) {
                            if (Thread.interrupted()) {
                                exitRequested = true;
                                break;
                            }
                            int upperByteOfAmplitude = abData[i];
                            if (upperByteOfAmplitude < 0)
                                upperByteOfAmplitude += 256;
                            int lowerByteOfAmplitude = abData[i + 1];
                            if (lowerByteOfAmplitude < 0)
                                lowerByteOfAmplitude += 256;
                            double amplitude16Bit = (upperByteOfAmplitude << 8) + (lowerByteOfAmplitude);
                            double amplitudeUnitVector = amplitude16Bit / 65535.0;// scale the amplitude to a 0-1.0
                                                                                    // scale
                            if (previousValue == null) {
                                // initialize the previous value
                                previousValue = amplitudeUnitVector;
                            }
                            if (buffer == null) {
                                // initialize the integral term
                                integralTotal = amplitudeUnitVector * getIntegralDepth();
                                buffer = getIntegralBuffer();
                                for (int j = 0; j < getIntegralDepth(); j++) {
                                    buffer[j] = amplitudeUnitVector;
                                }
                            }
                            // update the rolling total
                            integralTotal = integralTotal + amplitudeUnitVector - buffer[integralIndex];
                            // add current value to the buffer, overwriting previous buffer value
                            buffer[integralIndex] = amplitudeUnitVector;
                            integralIndex++;
                            // wrap the buffer circularly
                            if (integralIndex == getIntegralDepth())
                                integralIndex = 0;
                            // @Finn here are the integral and derivitives of amplitude to work with
                            double currentRollingAverage = integralTotal / getIntegralDepth() * getIntegralGain();
                            double currentDerivitiveTerm = (amplitudeUnitVector - previousValue) * getDerivitiveGain();
                            previousValue = amplitudeUnitVector;
                            double tmpAmtToRead = i - lastIndex;
                            double tmpTotal = total + tmpAmtToRead;
                            double len = (ais.getFrameLength() * 2);
                            double percentTmp = tmpTotal / len * 100.0;
 
                            AudioStatus newStat = lambda.update(status, amplitudeUnitVector, currentRollingAverage,
                                    currentDerivitiveTerm, percentTmp);
                            boolean change = newStat != status;
                            status = newStat;
                            // ensure the final frame is played
                            if (i == (nRead - 2)) {
                                change = true;
                            }
                            if (change) {
                                amountToRead = i - lastIndex;
                                total += amountToRead;
 
                                if (total >= (len - 2)) {
                                    status = AudioStatus.X_NO_SOUND;
                                }
                                double now = total;
                                double percent = now / len * 100.0;
                                speakProgress.update(percent, status);
                                getLine().write(abData, lastIndex, amountToRead);
                                lastIndex = i;
                            }
                        }
                    } else {
                        total += nRead;
                        double len = (ais.getFrameLength() * 2);
                        double now = total;
                        double percent = now / len * 100.0;
                        if (speakProgress != null)
                            speakProgress.update(percent, status);
                        getLine().write(abData, lastIndex, amountToRead);
                    }
 
                }
 
            }
        } catch (Throwable t) {
            t.printStackTrace();
        }
        try {
            if (speakProgress != null)
                speakProgress.update(100, AudioStatus.X_NO_SOUND);
        } catch (Throwable t) {
            t.printStackTrace();
        }
        if (!exitRequested) {
            getLine().drain();
        }
        getLine().close();
    }
 
    public void setLine(SourceDataLine line) {
        this.line = line;
    }
 
    public ISpeakingProgress getSpeakProgress() {
        return speakProgress;
    }
 
    public void setSpeakProgress(ISpeakingProgress speakProgress) {
        this.speakProgress = speakProgress;
    }
 
    public static double getThreshhold() {
        return threshhold;
    }
 
    public static void setThreshhold(double t) {
 
        threshhold = t;
    }
 
    public static double getLowerThreshhold() {
        return lowerThreshhold;
    }
 
    public static void setLowerThreshhold(double lt) {
 
        lowerThreshhold = lt;
    }
 
    public static int getIntegralDepth() {
        return integralDepth;
    }
 
    public static void setIntegralDepth(int integralDepth) {
        AudioPlayer.integralDepth = integralDepth;
    }
 
    private double[] getIntegralBuffer() {
        double[] ds = new double[getIntegralDepth()];
        return ds;
    }
 
    public static double getIntegralGain() {
        return integralGain;
    }
 
    public static void setIntegralGain(double integralGain) {
        AudioPlayer.integralGain = integralGain;
    }
 
    public static double getDerivitiveGain() {
        return derivitiveGain;
    }
 
    public static void setDerivitiveGain(double derivitiveGain) {
        AudioPlayer.derivitiveGain = derivitiveGain;
    }
 
    public static IAudioProcessingLambda getLambda() {
        return lambda;
    }
 
    public static void setLambda(IAudioProcessingLambda lambda) {
        AudioPlayer.lambda = lambda;
    }
 
}