// reads a chunk from the sound device
    public int getChunk(double[] chunkBuffer) {
        byte[] abBuffer = new byte[oneChunkSampleCount*2];
        int samplesRead = 0;

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

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

            // converting frames stored as bytes to double values
            samplesRead = bytesRead / 2;
            for (int i = 0; i < samplesRead; i++) {
                chunkBuffer[i] = ((abBuffer[i * 2] & 0xFF) | (abBuffer[i * 2 + 1] << 8)) / 32768.0;
            }
        } catch (InterruptedException e) {
        }
        return samplesRead;
    }

    // analyzes a chunk with FFT and returns the bit value
    public int demodulator() {
        int samplesRead = getChunk(signalLine1Buffer);

        // copying to the other line
        for (int i = 0; i < signalLine1Buffer.length; i++) {
            signalLine2Buffer[i] = signalLine1Buffer[i];
        }

        // emptying fft buffer in case of samples read != fft buffer length
        for (int i = 0; i < signalLine1FFTData.length; i++)
            signalLine1FFTData[i] = signalLine2FFTData[i] = 0;
        for (int i = 0; i < samplesRead; i++) {
            // copying audio data to the fft data buffer, imaginary part is 0
            signalLine1FFTData[2 * i] = signalLine1Buffer[i];
            signalLine1FFTData[2 * i + 1] = 0;

            signalLine2FFTData[2 * i] = signalLine2Buffer[i];
            signalLine2FFTData[2 * i + 1] = 0;
        }
        fft.complexForward(signalLine1FFTData);
        fft.complexForward(signalLine2FFTData);

        int binOfFreq0 = (int)Math.round((FREQ0*(signalLine1FFTData.length/2)/(double)SAMPLERATE)*2);
        int binOfFreq1 = (int)Math.round((FREQ1*(signalLine2FFTData.length/2)/(double)SAMPLERATE)*2);

        // zeroing out all freqs except the carrier on signal line 1
        for (int i = 0; i < signalLine1FFTData.length; i += 2) {
            if (i != binOfFreq0)
                signalLine1FFTData[i] = signalLine1FFTData[i + 1] = 0;
        }
        // zeroing out all freqs except the carrier on signal line 2
        for (int i = 0; i < signalLine2FFTData.length; i += 2) {
            if (i != binOfFreq1)
                signalLine2FFTData[i] = signalLine2FFTData[i + 1] = 0;
        }
        fft.complexInverse(signalLine1FFTData, false);
        fft.complexInverse(signalLine2FFTData, false);

        for (int i = 0; i < samplesRead; i++) {
            signalLine1Buffer[i] = signalLine1FFTData[2 * i];
            signalLine2Buffer[i] = signalLine2FFTData[2 * i];
            signalLine1Buffer[i] *= signalLine1Buffer[i]; // squaring
            signalLine2Buffer[i] *= signalLine2Buffer[i]; // squaring
            signalLine2Buffer[i] *= -1; // inverting signal line 2

            // summing the two signal lines
            signalLine1Buffer[i] += signalLine2Buffer[i];
        }

        int lowPassCutFreq = (int)Math.ceil(BITSPERSEC);
        int binOfLowPassCutFreq = (int)Math.round(((lowPassCutFreq * (signalLine1FFTData.length/2)) / (double)SAMPLERATE)*2);

        // lowpass filtering
        for (int i = 0; i < signalLine1FFTData.length; i++)
            signalLine1FFTData[i] = 0;
        for (int i = 0; i < samplesRead; i++) {
            // copying audio data to the fft data buffer, imaginary part is 0
            signalLine1FFTData[2 * i] = signalLine1Buffer[i];
            signalLine1FFTData[2 * i + 1] = 0;
        }
        fft.complexForward(signalLine1FFTData);

        for (int i = 0; i < signalLine1FFTData.length; i += 2) {
            if (i > binOfLowPassCutFreq)
                signalLine1FFTData[i] = signalLine1FFTData[i + 1] = 0;
        }
        fft.complexInverse(signalLine1FFTData, false);

        for (int i = 0; i < samplesRead; i++) {
            signalLine1Buffer[i] = signalLine1FFTData[2 * i] / 70;
        }
        baos.write(getBytesFromDoubles(signalLine1Buffer, samplesRead), 0, samplesRead * 2); // writing to the output wav for debugging purposes

        double average = 0;
        for (int i = 0; i < samplesRead; i++) {
            average += signalLine1Buffer[i];
        }
        average /= samplesRead;

        if (average > 0)
            return 0;
        else
            return 1;
    }

    // this function returns at the half of a bit with the bit's value
    public int getBitDPLL() {
        boolean chunkPhaseChanged = false;
        int chunkVal = -1;
        int chunkPhase = 0;

        while (chunkPhase < CHUNKCOUNTPERBIT) {
            chunkVal = demodulator();
            if (chunkVal == -1)
                break;

            if (!chunkPhaseChanged && chunkVal != oldChunkVal) {
                if (chunkPhase < CHUNKCOUNTPERBIT/2)
                    chunkPhase++; // early
                else
                    chunkPhase--; // late
                chunkPhaseChanged = true;
            }
            oldChunkVal = chunkVal;
            chunkPhase++;
        }

        // putting a tick to the output wav signing the moment when the DPLL returned
        /*baos.write(100);
        baos.write(100);
        baos.write(100);
        baos.write(100);
        baos.write(100);
        baos.write(100);*/
        return chunkVal;
    }

    // this function returns only when the start bit is successfully received
    public void waitForStartBit() {
        int bitResult;

        while (!Thread.interrupted()) {
            do {
                bitResult = demodulator();
            } while ((bitResult == 0 || bitResult == -1) && !Thread.interrupted());
           
            //System.out.println("sb0: 1");
           
            do {
                bitResult = demodulator();
            } while ((bitResult == 1 || bitResult == -1) && !Thread.interrupted());
           
            //System.out.println("sb1: 0");

            // waiting half bit time
            for (int i = 0; i < CHUNKCOUNTPERBIT/2; i++)
                bitResult = demodulator();

            //System.out.println("sb2: " + bitResult);

            if (bitResult == 0)
                break;
        }
        //System.out.println("start bit ok");
    }
   
    @Override
    public void run() {
        tdl.start();

        int byteResult = 0;
        int byteResultp = 0;
        int bitResult;
       
        while (!Thread.interrupted()) {
            waitForStartBit();
           
            System.out.print("0 "); // first bit is the start bit, it's zero
           
            // reading 7 more bits
            for (byteResultp = 1, byteResult = 0; byteResultp < 8; byteResultp++) {
                bitResult = getBitDPLL();
                if (bitResult == -1) {
                    byteResult = -1;
                    break;
                }

                switch (byteResultp) {
                    case 6: // stop bit 1
                        System.out.print(" " + bitResult);
                        break;
                    case 7: // stop bit 2
                        System.out.print(bitResult);
                        break;
                    default:
                        System.out.print(bitResult);
                        byteResult += bitResult << (byteResultp-1);
                }
            }

            if (byteResult == -1)
                continue;

            switch (byteResult) {
                case 31:
                    mode = RTTYMode.letters;
                    System.out.println(" ^L^");
                    break;
                case 27:
                    mode = RTTYMode.symbols;
                    System.out.println(" ^F^");
                    break;
                default:
                    switch (mode) {
                    case letters:
                        System.out.println(" *** " + RTTYLetters[byteResult] + "(" + byteResult + ")");
                        break;
                    case symbols:
                        System.out.println(" *** " + RTTYSymbols[byteResult] + "(" + byteResult + ")");
                        break;
                    }
            }
        }

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