// for filter designing, see http://www-users.cs.york.ac.uk/~fisher/mkfilter/
    // order 2 Butterworth, freqs: 865-965 Hz
    public double bandPassFreq0(double sampleIn) {
        xvBP0[0] = xvBP0[1]; xvBP0[1] = xvBP0[2]; xvBP0[2] = xvBP0[3]; xvBP0[3] = xvBP0[4];
        xvBP0[4] = sampleIn / 2.356080041e+04;
        yvBP0[0] = yvBP0[1]; yvBP0[1] = yvBP0[2]; yvBP0[2] = yvBP0[3]; yvBP0[3] = yvBP0[4];
        yvBP0[4] = (xvBP0[0] + xvBP0[4]) - 2 * xvBP0[2]
                    + (-0.9816582826 * yvBP0[0]) + (3.9166274264 * yvBP0[1])
                    + (-5.8882201843 * yvBP0[2]) + (3.9530488323 * yvBP0[3]);
        return yvBP0[4];
    }

    // order 2 Butterworth, freqs: 1035-1135 Hz
    public double bandPassFreq1(double sampleIn) {
        xvBP1[0] = xvBP1[1]; xvBP1[1] = xvBP1[2]; xvBP1[2] = xvBP1[3]; xvBP1[3] = xvBP1[4];
        xvBP1[4] = sampleIn / 2.356080365e+04;
        yvBP1[0] = yvBP1[1]; yvBP1[1] = yvBP1[2]; yvBP1[2] = yvBP1[3]; yvBP1[3] = yvBP1[4];
        yvBP1[4] = (xvBP1[0] + xvBP1[4]) - 2 * xvBP1[2]
                    + (-0.9816582826 * yvBP1[0]) + (3.9051693660 * yvBP1[1])
                    + (-5.8653953990 * yvBP1[2]) + (3.9414842213 * yvBP1[3]);
        return yvBP1[4];
    }

    // order 2 Butterworth, freq: 50 Hz
    public double lowPass(double sampleIn) {
        xvLP[0] = xvLP[1]; xvLP[1] = xvLP[2];
        xvLP[2] = sampleIn / 9.381008646e+04;
        yvLP[0] = yvLP[1]; yvLP[1] = yvLP[2];
        yvLP[2] = (xvLP[0] + xvLP[2]) + 2 * xvLP[1]
                   + (-0.9907866988 * yvLP[0]) + (1.9907440595 * yvLP[1]);
        return yvLP[2];
    }

    // this function returns the bit value of the current sample
    public int demodulator() {
        double sample = getSample();

        double line0 = bandPassFreq0(sample);
        double line1 = bandPassFreq1(sample);
        // calculating the RMS of the two lines (squaring them)
        line0 *= line0;
        line1 *= line1;

        // inverting line 1
        line1 *= -1;

        // summing the two lines
        line0 += line1;

        // lowpass filtering the summed line
        line0 = lowPass(line0);

        baos.write(getBytesFromDouble(line0), 0, 2); // writing to the output wav for debugging purposes

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

    // this function returns at the half of a bit with the bit's value
    public int getBitDPLL() {
        boolean phaseChanged = false;
        int val = 0;

        while (DPLLBitPhase < oneBitSampleCount) {
            val = demodulator();

            if (!phaseChanged && val != DPLLOldVal) {
                if (DPLLBitPhase < oneBitSampleCount/2)
                    DPLLBitPhase += oneBitSampleCount/8; // early
                else
                    DPLLBitPhase -= oneBitSampleCount/8; // late
                phaseChanged = true;
            }
            DPLLOldVal = val;
            DPLLBitPhase++;
        }
        DPLLBitPhase -= oneBitSampleCount;

        // 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 val;
    }

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

        while (!Thread.interrupted()) {
            // waiting for a falling edge
            do {
                bitResult = demodulator();
            } while (bitResult == 0 && !Thread.interrupted());
           
            do {
                bitResult = demodulator();
            } while (bitResult == 1 && !Thread.interrupted());

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

            if (bitResult == 0)
                break;
        }
    }
   
    @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();

                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);
                }
            }

            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();
    }