public class SSBWeaver implements Runnable {
    private final static int SAMPLERATE = 44100;
    private final static int BUFFERSIZE = SAMPLERATE * 2;
    private final static int IIR_NZEROS = 10;
    private final static int IIR_NPOLES = 10;
    private final static double IIR_GAIN = 3.452507086e+02;

    // these are used for the two lowpass filters
    private double xv_H[], yv_H[];
    private double xv_L[], yv_L[];

    private TargetDataLine tdl;
    //private DoubleFFT_1D fft;

    public SSBWeaver(TargetDataLine tdl) {
        this.tdl = tdl;
    }

    // IIR Butterworth lowpass filter 1
    // see http://www-users.cs.york.ac.uk/~fisher/mkfilter/
    private double lowPassFilterH(double in) {
        xv_H[0] = xv_H[1];
        xv_H[1] = xv_H[2];
        xv_H[2] = xv_H[3];
        xv_H[3] = xv_H[4];
        xv_H[4] = xv_H[5];
        xv_H[5] = xv_H[6];
        xv_H[6] = xv_H[7];
        xv_H[7] = xv_H[8];
        xv_H[8] = xv_H[9];
        xv_H[9] = xv_H[10];
        xv_H[10] = in / IIR_GAIN;
        yv_H[0] = yv_H[1];
        yv_H[1] = yv_H[2];
        yv_H[2] = yv_H[3];
        yv_H[3] = yv_H[4];
        yv_H[4] = yv_H[5];
        yv_H[5] = yv_H[6];
        yv_H[6] = yv_H[7];
        yv_H[7] = yv_H[8];
        yv_H[8] = yv_H[9];
        yv_H[9] = yv_H[10];
        yv_H[10] = (xv_H[0] + xv_H[10]) + 10 * (xv_H[1] + xv_H[9]) + 45 * (xv_H[2] + xv_H[8]) + 120 * (xv_H[3] + xv_H[7]) + 210 * (xv_H[4] + xv_H[6]) + 252 * xv_H[5] + (-0.0000357500 * yv_H[0]) + (0.0006094904 * yv_H[1]) + (-0.0061672448 * yv_H[2]) + (0.0298428117 * yv_H[3]) + (-0.1344215690 * yv_H[4]) + (0.3160380661 * yv_H[5]) + (-0.8283557825 * yv_H[6]) + (1.0214778432 * yv_H[7]) + (-1.7026748886 * yv_H[8]) + (0.9259874207 * yv_H[9]);
        return yv_H[10];
    }

    // IIR Butterworth lowpass filter 2
    private double lowPassFilterL(double in) {
        xv_L[0] = xv_L[1];
        xv_L[1] = xv_L[2];
        xv_L[2] = xv_L[3];
        xv_L[3] = xv_L[4];
        xv_L[4] = xv_L[5];
        xv_L[5] = xv_L[6];
        xv_L[6] = xv_L[7];
        xv_L[7] = xv_L[8];
        xv_L[8] = xv_L[9];
        xv_L[9] = xv_L[10];
        xv_L[10] = in / IIR_GAIN;
        yv_L[0] = yv_L[1];
        yv_L[1] = yv_L[2];
        yv_L[2] = yv_L[3];
        yv_L[3] = yv_L[4];
        yv_L[4] = yv_L[5];
        yv_L[5] = yv_L[6];
        yv_L[6] = yv_L[7];
        yv_L[7] = yv_L[8];
        yv_L[8] = yv_L[9];
        yv_L[9] = yv_L[10];
        yv_L[10] = (xv_L[0] + xv_L[10]) + 10 * (xv_L[1] + xv_L[9]) + 45 * (xv_L[2] + xv_L[8]) + 120 * (xv_L[3] + xv_L[7]) + 210 * (xv_L[4] + xv_L[6]) + 252 * xv_L[5] + (-0.0000357500 * yv_L[0]) + (0.0006094904 * yv_L[1]) + (-0.0061672448 * yv_L[2]) + (0.0298428117 * yv_L[3]) + (-0.1344215690 * yv_L[4]) + (0.3160380661 * yv_L[5]) + (-0.8283557825 * yv_L[6]) + (1.0214778432 * yv_L[7]) + (-1.7026748886 * yv_L[8]) + (0.9259874207 * yv_L[9]);
        return yv_L[10];
    }
/*
    private void lowPassFilterFFT(double[] audioData, final int storedSamples, final double cutFreq) {
        // we need to initialize a buffer where we store our samples as complex numbers. first value is the real part, second is the imaginary.
        double[] fftData = new double[audioData.length * 2];
        for (int i = 0; i < storedSamples; i++) {
            // copying audio data to the fft data buffer, imaginary part is 0
            fftData[2 * i] = audioData[i];
            fftData[2 * i + 1] = 0;
        }

        // calculating the fft of the data, so we will have spectral power of each frequency component
        fft.complexForward(fftData);

        for (int i = 0; i < fftData.length; i += 2) {
            // lowpass
            if (i > ((cutFreq * (fftData.length/2)) / SAMPLERATE)*2)
                fftData[i] = fftData[i + 1] = 0;
        }

        // built-in scaling hangs the thread, so we don't use it
        fft.complexInverse(fftData, false);

        for (int i = 0; i < storedSamples; i++) {
            audioData[i] = fftData[2 * i] / (SAMPLERATE / 4.0); // applying scaling
        }
    }
*/
    // converts float array to byte array
    private byte[] getBytesFromDoubles(final double[] audioData, final int storedSamples) {
        byte[] audioDataBytes = new byte[storedSamples * 2];

        for (int i = 0; i < storedSamples; i++) {
            // saturation
            audioData[i] = Math.min(1.0, Math.max(-1.0, audioData[i]));

            // scaling and conversion to integer
            int sample = (int) Math.round((audioData[i] + 1.0) * 32767.5) - 32768;

            byte high = (byte) ((sample >> 8) & 0xFF);
            byte low = (byte) (sample & 0xFF);
            audioDataBytes[i * 2] = low;
            audioDataBytes[i * 2 + 1] = high;
        }

        return audioDataBytes;
    }

    // saves the audio data given in audioDataBytes to a .wav file
    private void writeWavFile(final byte[] audioDataBytes, final int storedSamples, final String fileName) {
        AudioFormat audioFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, SAMPLERATE, 16, 1, 2, SAMPLERATE, false);
        AudioInputStream audioInputStream = new AudioInputStream(new ByteArrayInputStream(audioDataBytes), audioFormat, storedSamples);

        try {
            FileOutputStream fileOutputStream = new FileOutputStream(fileName);
            AudioSystem.write(audioInputStream, AudioFileFormat.Type.WAVE, fileOutputStream);
            audioInputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        byte[] abBuffer = new byte[tdl.getBufferSize()];
        double[] abBufferDouble = new double[abBuffer.length / 2];
        ByteArrayOutputStream baos = new ByteArrayOutputStream(); // this will store sound data
        double osc1Phase = 0, osc2Phase = 0;
        double carrierFreq = 10000;
        double osc1Freq = SAMPLERATE/4;
        double osc2Freq = osc1Freq - carrierFreq; // pitch shift is given by the difference between the two oscillators
        double demodPhase = 0;

        //fft = new DoubleFFT_1D(abBufferDouble.length);
        double[] lp_H = new double[abBufferDouble.length];
        double[] lp_L = new double[abBufferDouble.length];

        xv_H = new double[IIR_NZEROS + 1];
        yv_H = new double[IIR_NPOLES + 1];
        xv_L = new double[IIR_NZEROS + 1];
        yv_L = new double[IIR_NPOLES + 1];

        tdl.start();

        try {
            while (!Thread.interrupted()) {
                // waiting for the buffer to get filled
                while (tdl.available() < tdl.getBufferSize() * 0.5)
                    Thread.sleep(0, 1); // without this, the audio will be choppy

                int bytesRead = tdl.read(abBuffer, 0, tdl.available());

                // converting frames stored as bytes to double values
                int samplesRead = bytesRead / tdl.getFormat().getFrameSize();
                for (int i = 0; i < samplesRead; i++)
                    abBufferDouble[i] = ((abBuffer[i * 2] & 0xFF) | (abBuffer[i * 2 + 1] << 8)) / 32768.0;

                for (int samplePos = 0; samplePos < samplesRead; samplePos++) {
                    osc1Phase += (2 * Math.PI * osc1Freq) / SAMPLERATE;

                    lp_H[samplePos] = abBufferDouble[samplePos] * Math.sin(osc1Phase);
                    lp_L[samplePos] = abBufferDouble[samplePos] * Math.cos(osc1Phase);

                    if (osc1Phase >= 2 * Math.PI)
                        osc1Phase -= 2 * Math.PI;
                }

                // filtering can be done using FFT also
                //lowPassFilterFFT(l1, samplesRead, osc1Freq);
                //lowPassFilterFFT(l2, samplesRead, osc1Freq);
                for (int samplePos = 0; samplePos < samplesRead; samplePos++) {
                    lp_H[samplePos] = lowPassFilterH(lp_H[samplePos]);
                    lp_L[samplePos] = lowPassFilterL(lp_L[samplePos]);
                }

                // compensating the delay of the IIR filter by delaying osc2
                for (int i = 0; i < IIR_NZEROS; i++) {
                    osc2Phase += (2 * Math.PI * osc2Freq) / SAMPLERATE;
                    if (osc2Phase >= 2 * Math.PI)
                        osc2Phase -= 2 * Math.PI;
                }

                for (int samplePos = 0; samplePos < samplesRead; samplePos++) {
                    osc2Phase += (2 * Math.PI * osc2Freq) / SAMPLERATE;

                    lp_H[samplePos] *= Math.sin(osc2Phase);
                    lp_L[samplePos] *= Math.cos(osc2Phase);

                    abBufferDouble[samplePos] = lp_H[samplePos] + lp_L[samplePos];

                    if (osc2Phase >= 2 * Math.PI)
                        osc2Phase -= 2 * Math.PI;
                }

                // demodulating (multiplying samples with the carrier again)
                /*for (int samplePos = 0; samplePos < samplesRead; samplePos++) {
                    demodPhase += (2 * Math.PI * carrierFreq) / SAMPLERATE;
                    abBufferDouble[samplePos] *= Math.sin(demodPhase);

                    if (demodPhase >= 2 * Math.PI)
                        demodPhase -= 2 * Math.PI;
                }*/

                baos.write(getBytesFromDoubles(abBufferDouble, samplesRead), 0, samplesRead * 2);
            }
        } catch (InterruptedException e) {
        }

        tdl.stop();
        tdl.close();

        writeWavFile(baos.toByteArray(), baos.size() / 2, "output.wav");
    }

    public static void main(String[] args) {
        AudioFormat audioFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, SAMPLERATE, 16, 1, 2, SAMPLERATE, false);
        DataLine.Info info = new DataLine.Info(TargetDataLine.class, audioFormat, BUFFERSIZE);

        TargetDataLine targetDataLine = null;
        try {
            targetDataLine = (TargetDataLine) AudioSystem.getLine(info);
            targetDataLine.open(audioFormat, BUFFERSIZE);
            System.out.println("Buffer size: " + targetDataLine.getBufferSize());
        } catch (LineUnavailableException e1) {
            e1.printStackTrace();
        }

        // creating the recorder thread from this class' instance
        SSBWeaver ssbWeaver = new SSBWeaver(targetDataLine);
        Thread ssbWeaverThread = new Thread(ssbWeaver);

        // we use this to read line from the standard input
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        ssbWeaverThread.setPriority(Thread.MAX_PRIORITY);
        ssbWeaverThread.start();

        System.out.println("Recording... press ENTER to stop recording!");
        try {
            br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }

        ssbWeaverThread.interrupt();

        try {
            // waiting for the recorder thread to stop
            ssbWeaverThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Recording stopped.");
    }

}