import sys, math

DOT = 30

DAH = 80

OCTAVE = 2                              # 1 == 441 Hz, 2 == 882 Hz, ...

SAMPWIDTH = 2

FRAMERATE = 44100

BASEFREQ = 441

QSIZE = 20000

morsetab = {

        'A': '.-',              'a': '.-',

        'B': '-...',            'b': '-...',

        'C': '-.-.',            'c': '-.-.',

        'D': '-..',             'd': '-..',

        'E': '.',               'e': '.',

        'F': '..-.',            'f': '..-.',

        'G': '--.',             'g': '--.',

        'H': '....',            'h': '....',

        'I': '..',              'i': '..',

        'J': '.---',            'j': '.---',

        'K': '-.-',             'k': '-.-',

        'L': '.-..',            'l': '.-..',

        'M': '--',              'm': '--',

        'N': '-.',              'n': '-.',

        'O': '---',             'o': '---',

        'P': '.--.',            'p': '.--.',

        'Q': '--.-',            'q': '--.-',

        'R': '.-.',             'r': '.-.',

        'S': '...',             's': '...',

        'T': '-',               't': '-',

        'U': '..-',             'u': '..-',

        'V': '...-',            'v': '...-',

        'W': '.--',             'w': '.--',

        'X': '-..-',            'x': '-..-',

        'Y': '-.--',            'y': '-.--',

        'Z': '--..',            'z': '--..',

        '0': '-----',

        '1': '.----',

        '2': '..---',

        '3': '...--',

        '4': '....-',

        '5': '.....',

        '6': '-....',

        '7': '--...',

        '8': '---..',

        '9': '----.',

        ',': '--..--',

        '.': '.-.-.-',

        '?': '..--..',

        ';': '-.-.-.',

        ':': '---...',

        "'": '.----.',

        '-': '-....-',

        '/': '-..-.',

        '(': '-.--.-',

        ')': '-.--.-',

        '_': '..--.-',

        ' ': ' '

}

# If we play at 44.1 kHz (which we do), then if we produce one sine

# wave in 100 samples, we get a tone of 441 Hz.  If we produce two

# sine waves in these 100 samples, we get a tone of 882 Hz.  882 Hz

# appears to be a nice one for playing morse code.

def mkwave(octave):

    global sinewave, nowave

    sinewave = ''

    n = int(FRAMERATE / BASEFREQ)

    for i in range(n):

        val = int(math.sin(2 * math.pi * i * octave / n) * 0x7fff)

        sample = chr((val >> 8) & 255) + chr(val & 255)

        sinewave = sinewave + sample[:SAMPWIDTH]

    nowave = '\0' * (n*SAMPWIDTH)

mkwave(OCTAVE)

class BufferedAudioDev:

    def __init__(self, *args):

        import audiodev

        self._base = apply(audiodev.AudioDev, args)

        self._buffer = []

        self._filled = 0

        self._addmethods(self._base, self._base.__class__)

    def _addmethods(self, inst, cls):

        for name in cls.__dict__.keys():

            if not hasattr(self, name):

                try:

                    setattr(self, name, getattr(inst, name))

                except:

                    pass

        for basecls in cls.__bases__:

            self._addmethods(self, inst, basecls)

    def writeframesraw(self, frames):

        self._buffer.append(frames)

        self._filled = self._filled + len(frames)

        if self._filled >= QSIZE:

            self.flush()

    def wait(self):

        self.flush()

        self._base.wait()

    def flush(self):

        print 'flush: %d blocks, %d bytes' % (len(self._buffer), self._filled)

        if self._buffer:

            import string

            self._base.writeframes(string.joinfields(self._buffer, ''))

            self._buffer = []

            self._filled = 0

def main(args = sys.argv[1:]):

    import getopt, string

    try:

        opts, args = getopt.getopt(args, 'o:p:')

    except getopt.error:

        sys.stderr.write('Usage ' + sys.argv[0] +

                         ' [ -o outfile ] [ args ] ...\n')

        sys.exit(1)

    dev = None

    for o, a in opts:

        if o == '-o':

            import aifc

            dev = aifc.open(a, 'w')

            dev.setframerate(FRAMERATE)

            dev.setsampwidth(SAMPWIDTH)

            dev.setnchannels(1)

        if o == '-p':

            mkwave(string.atoi(a))

    if not dev:

        dev = BufferedAudioDev()

        dev.setoutrate(FRAMERATE)

        dev.setsampwidth(SAMPWIDTH)

        dev.setnchannels(1)

        dev.close = dev.stop

    if args:

        line = string.join(args)

    else:

        line = sys.stdin.readline()

    while line:

        print line

        mline = morse(line)

        print mline

        play(mline, dev)

        if hasattr(dev, 'wait'):

            dev.wait()

        if not args:

            line = sys.stdin.readline()

        else:

            line = ''

    dev.close()

# Convert a string to morse code with \001 between the characters in

# the string.

def morse(line):

    res = ''

    for c in line:

        try:

            res = res + morsetab[c] + '\001'

        except KeyError:

            pass

    return res

# Play a line of morse code.

def play(line, dev):

    for c in line:

        if c == '.':

            sine(dev, DOT)

        elif c == '-':

            sine(dev, DAH)

        else:

            pause(dev, DAH)

        pause(dev, DOT)

def sine(dev, length):

    dev.writeframesraw(sinewave*length)

def pause(dev, length):

    dev.writeframesraw(nowave*length)

if __name__ == '__main__' or sys.argv[0] == __name__:

    main()