// 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 based on the averaged spectral power at the mark and space freqs
    public int demodulator() {
        int samplesRead = getChunk(chunkBuffer);

        baos.write(getBytesFromDoubles(chunkBuffer, samplesRead), 0, samplesRead * 2);  // writing to the output wav for debugging purposes

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

        // calculating the fft of the data, so we will have spectral power of each frequency component
        // fft resolution (number of bins) is samplesNum, because we initialized with that value
        fft.complexForward(fftData);

        double PWRFreq0 = Math.sqrt(fftData[binOfFreq0] * fftData[binOfFreq0] + fftData[binOfFreq0+1] * fftData[binOfFreq0+1]);
        double PWRFreq1 = Math.sqrt(fftData[binOfFreq1] * fftData[binOfFreq1] + fftData[binOfFreq1+1] * fftData[binOfFreq1+1]);

        if (PWRFreq0 > PWRTHRESHOLD || PWRFreq1 > PWRTHRESHOLD) {
            if (PWRFreq0-PWRFreq1 < 0)
                return 1;
            else
                return 0;
        }
        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();
    }