#! /usr/bin/env python

"""audiopy -- a program to control the Solaris audio device.

Contact: Barry Warsaw

Email:   bwarsaw@python.org

Version: %(__version__)s

When no arguments are given, this pops up a graphical window which lets you

choose the audio input and output devices, and set the output volume.

This program can be driven via the command line, and when done so, no window

pops up.  Most options have the general form:

    --device[={0,1}]

    -d[={0,1}]

        Set the I/O device.  With no value, it toggles the specified device.

        With a value, 0 turns the device off and 1 turns the device on.

The list of devices and their short options are:

 (input)

    microphone  -- m

    linein      -- i

    cd          -- c

 (output)

    headphones  -- p

    speaker     -- s

    lineout     -- o

Other options are:

    --gain volume

    -g volume

        Sets the output gain to the specified volume, which must be an integer

        in the range [%(MIN_GAIN)s..%(MAX_GAIN)s]

    --version

    -v

        Print the version number and exit.

    --help

    -h

        Print this message and exit.

"""

import sys

import os

import errno

import sunaudiodev

from SUNAUDIODEV import *

# Milliseconds between interrupt checks

KEEPALIVE_TIMER = 500

__version__ = '1.1'

class MainWindow:

    def __init__(self, device):

        from Tkinter import *

        self.__helpwin = None

        self.__devctl = device

        info = device.getinfo()

        #

        self.__tkroot = tkroot = Tk(className='Audiopy')

        tkroot.withdraw()

        # create the menubar

        menubar = Menu(tkroot)

        filemenu = Menu(menubar, tearoff=0)

        filemenu.add_command(label='Quit',

                             command=self.__quit,

                             accelerator='Alt-Q',

                             underline=0)

        helpmenu = Menu(menubar, name='help', tearoff=0)

        helpmenu.add_command(label='About Audiopy...',

                             command=self.__popup_about,

                             underline=0)

        helpmenu.add_command(label='Help...',

                             command=self.__popup_using,

                             underline=0)

        menubar.add_cascade(label='File',

                            menu=filemenu,

                            underline=0)

        menubar.add_cascade(label='Help',

                            menu=helpmenu,

                            underline=0)

        # now create the top level window

        root = self.__root = Toplevel(tkroot, class_='Audiopy', menu=menubar)

        root.protocol('WM_DELETE_WINDOW', self.__quit)

        root.title('audiopy ' + __version__)

        root.iconname('audiopy ' + __version__)

        root.tk.createtimerhandler(KEEPALIVE_TIMER, self.__keepalive)

        #

        buttons = []

        #

        # where does input come from?

        frame = Frame(root, bd=1, relief=RAISED)

        frame.grid(row=1, column=0, sticky='NSEW')

        label = Label(frame, text='Input From:')

        label.grid(row=0, column=0, sticky=E)

        self.__inputvar = IntVar()

        ##

        btn = Radiobutton(frame,

                          text='None',

                          variable=self.__inputvar,

                          value=0,

                          command=self.__pushtodev,

                          underline=0)

        btn.grid(row=0, column=1, sticky=W)

        root.bind('<Alt-n>', self.__none)

        root.bind('<Alt-N>', self.__none)

        if not info.i_avail_ports & MICROPHONE:

            btn.configure(state=DISABLED)

        buttons.append(btn)

        ##

        btn = Radiobutton(frame,

                          text='Microphone',

                          variable=self.__inputvar,

                          value=MICROPHONE,

                          command=self.__pushtodev,

                          underline=0)

        btn.grid(row=1, column=1, sticky=W)

        root.bind('<Alt-m>', self.__mic)

        root.bind('<Alt-M>', self.__mic)

        if not info.i_avail_ports & MICROPHONE:

            btn.configure(state=DISABLED)

        buttons.append(btn)

        ##

        btn = Radiobutton(frame,

                          text='Line In',

                          variable=self.__inputvar,

                          value=LINE_IN,

                          command=self.__pushtodev,

                          underline=5)

        btn.grid(row=2, column=1, sticky=W)

        root.bind('<Alt-i>', self.__linein)

        root.bind('<Alt-I>', self.__linein)

        if not info.i_avail_ports & LINE_IN:

            btn.configure(state=DISABLED)

        buttons.append(btn)

        ## if SUNAUDIODEV was built on an older version of Solaris, the CD

        ## input device won't exist

        try:

            btn = Radiobutton(frame,

                              text='CD',

                              variable=self.__inputvar,

                              value=CD,

                              command=self.__pushtodev,

                              underline=0)

            btn.grid(row=3, column=1, sticky=W)

            root.bind('<Alt-c>', self.__cd)

            root.bind('<Alt-C>', self.__cd)

            if not info.i_avail_ports & CD:

                btn.configure(state=DISABLED)

            buttons.append(btn)

        except NameError:

            pass

        #

        # where does output go to?

        frame = Frame(root, bd=1, relief=RAISED)

        frame.grid(row=2, column=0, sticky='NSEW')

        label = Label(frame, text='Output To:')

        label.grid(row=0, column=0, sticky=E)

        self.__spkvar = IntVar()

        btn = Checkbutton(frame,

                          text='Speaker',

                          variable=self.__spkvar,

                          onvalue=SPEAKER,

                          command=self.__pushtodev,

                          underline=0)

        btn.grid(row=0, column=1, sticky=W)

        root.bind('<Alt-s>', self.__speaker)

        root.bind('<Alt-S>', self.__speaker)

        if not info.o_avail_ports & SPEAKER:

            btn.configure(state=DISABLED)

        buttons.append(btn)

        ##

        self.__headvar = IntVar()

        btn = Checkbutton(frame,

                          text='Headphones',

                          variable=self.__headvar,

                          onvalue=HEADPHONE,

                          command=self.__pushtodev,

                          underline=4)

        btn.grid(row=1, column=1, sticky=W)

        root.bind('<Alt-p>', self.__headphones)

        root.bind('<Alt-P>', self.__headphones)

        if not info.o_avail_ports & HEADPHONE:

            btn.configure(state=DISABLED)

        buttons.append(btn)

        ##

        self.__linevar = IntVar()

        btn = Checkbutton(frame,

                          variable=self.__linevar,

                          onvalue=LINE_OUT,

                          text='Line Out',

                          command=self.__pushtodev,

                          underline=0)

        btn.grid(row=2, column=1, sticky=W)

        root.bind('<Alt-l>', self.__lineout)

        root.bind('<Alt-L>', self.__lineout)

        if not info.o_avail_ports & LINE_OUT:

            btn.configure(state=DISABLED)

        buttons.append(btn)

        #

        # Fix up widths

        widest = 0

        for b in buttons:

            width = b['width']

            if width > widest:

                widest = width

        for b in buttons:

            b.configure(width=widest)

        # root bindings

        root.bind('<Alt-q>', self.__quit)

        root.bind('<Alt-Q>', self.__quit)

        #

        # Volume

        frame = Frame(root, bd=1, relief=RAISED)

        frame.grid(row=3, column=0, sticky='NSEW')

        label = Label(frame, text='Output Volume:')

        label.grid(row=0, column=0, sticky=W)

        self.__scalevar = IntVar()

        self.__scale = Scale(frame,

                             orient=HORIZONTAL,

                             from_=MIN_GAIN,

                             to=MAX_GAIN,

                             length=200,

                             variable=self.__scalevar,

                             command=self.__volume)

        self.__scale.grid(row=1, column=0, sticky=EW)

        #

        # do we need to poll for changes?

        self.__needtopoll = 1

        try:

            fd = self.__devctl.fileno()

            self.__needtopoll = 0

        except AttributeError:

            pass

        else:

            import fcntl

            import signal

            import STROPTS

            # set up the signal handler

            signal.signal(signal.SIGPOLL, self.__update)

            fcntl.ioctl(fd, STROPTS.I_SETSIG, STROPTS.S_MSG)

            self.__update()

    def __quit(self, event=None):

        self.__devctl.close()

        self.__root.quit()

    def __popup_about(self, event=None):

        import tkMessageBox

        tkMessageBox.showinfo('About Audiopy ' + __version__,

                              '''\

Audiopy %s

Control the Solaris audio device

For information

Contact: Barry A. Warsaw

Email:   bwarsaw@python.org''' % __version__)

    def __popup_using(self, event=None):

        if not self.__helpwin:

            self.__helpwin = Helpwin(self.__tkroot, self.__quit)

        self.__helpwin.deiconify()

    def __keepalive(self):

        # Exercise the Python interpreter regularly so keyboard interrupts get

        # through.

        self.__tkroot.tk.createtimerhandler(KEEPALIVE_TIMER, self.__keepalive)

        if self.__needtopoll:

            self.__update()

    def __update(self, num=None, frame=None):

        # It's possible (although I have never seen it) to get an interrupted

        # system call during the getinfo() call.  If so, and we're polling,

        # don't sweat it because we'll come around again later.  Otherwise,

        # we'll give it a couple of tries and then give up until next time.

        tries = 0

        while 1:

            try:

                info = self.__devctl.getinfo()

                break

            except sunaudiodev.error:

                if self.__needtopoll or tries > 3:

                    return

                tries = tries + 1

        # input

        self.__inputvar.set(info.i_port)

        # output

        self.__spkvar.set(info.o_port & SPEAKER)

        self.__headvar.set(info.o_port & HEADPHONE)

        self.__linevar.set(info.o_port & LINE_OUT)

        # volume

        self.__scalevar.set(info.o_gain)

    def __pushtodev(self, event=None):

        info = self.__devctl.getinfo()

        info.o_port = self.__spkvar.get() + \

                      self.__headvar.get() + \

                      self.__linevar.get()

        info.i_port = self.__inputvar.get()

        info.o_gain = self.__scalevar.get()

        try:

            self.__devctl.setinfo(info)

        except sunaudiodev.error, msg:

            # TBD: what to do?  it's probably temporary.

            pass

    def __getset(self, var, onvalue):

        if var.get() == onvalue:

            var.set(0)

        else:

            var.set(onvalue)

        self.__pushtodev()

    def __none(self, event=None):

        self.__inputvar.set(0)

        self.__pushtodev()

    def __mic(self, event=None):

        self.__getset(self.__inputvar, MICROPHONE)

    def __linein(self, event=None):

        self.__getset(self.__inputvar, LINE_IN)

    def __cd(self, event=None):

        self.__getset(self.__inputvar, CD)

    def __speaker(self, event=None):

        self.__getset(self.__spkvar, SPEAKER)

    def __headphones(self, event=None):

        self.__getset(self.__headvar, HEADPHONE)

    def __lineout(self, event=None):

        self.__getset(self.__linevar, LINE_OUT)

    def __volume(self, event=None):

        self.__pushtodev()

    def start(self):

        self.__keepalive()

        self.__tkroot.mainloop()

class Helpwin:

    def __init__(self, master, quitfunc):

        from Tkinter import *

        self.__root = root = Toplevel(master, class_='Audiopy')

        root.protocol('WM_DELETE_WINDOW', self.__withdraw)

        root.title('Audiopy Help Window')

        root.iconname('Audiopy Help Window')

        root.bind('<Alt-q>', quitfunc)

        root.bind('<Alt-Q>', quitfunc)

        root.bind('<Alt-w>', self.__withdraw)

        root.bind('<Alt-W>', self.__withdraw)

        # more elaborate help is available in the README file

        readmefile = os.path.join(sys.path[0], 'README')

        try:

            fp = None

            try:

                fp = open(readmefile)

                contents = fp.read()

                # wax the last page, it contains Emacs cruft

                i = contents.rfind('\f')

                if i > 0:

                    contents = contents[:i].rstrip()

            finally:

                if fp:

                    fp.close()

        except IOError:

            sys.stderr.write("Couldn't open audiopy's README, "

                             'using docstring instead.\n')

            contents = __doc__ % globals()

        self.__text = text = Text(root, relief=SUNKEN,

                                  width=80, height=24)

        text.insert(0.0, contents)

        scrollbar = Scrollbar(root)

        scrollbar.pack(fill=Y, side=RIGHT)

        text.pack(fill=BOTH, expand=YES)

        text.configure(yscrollcommand=(scrollbar, 'set'))

        scrollbar.configure(command=(text, 'yview'))

    def __withdraw(self, event=None):

        self.__root.withdraw()

    def deiconify(self):

        self.__root.deiconify()

def usage(code, msg=''):

    print __doc__ % globals()

    if msg:

        print msg

    sys.exit(code)

def main():

    #

    # Open up the audio control device and query for the current output

    # device

    device = sunaudiodev.open('control')

    if len(sys.argv) == 1:

        # GUI

        w = MainWindow(device)

        try:

            w.start()

        except KeyboardInterrupt:

            pass

        return

    # spec:    LONG OPT, SHORT OPT, 0=input,1=output, MASK

    options = [('--microphone', '-m', 0, MICROPHONE),

               ('--linein',     '-i', 0, LINE_IN),

               ('--headphones', '-p', 1, HEADPHONE),

               ('--speaker',    '-s', 1, SPEAKER),

               ('--lineout',    '-o', 1, LINE_OUT),

               ]

    # See the comment above about `CD'

    try:

        options.append(('--cd',         '-c', 0, CD))

    except NameError:

        pass

    info = device.getinfo()

    # first get the existing values

    i = 0

    while i < len(sys.argv)-1:

        i = i + 1

        arg = sys.argv[i]

        if arg in ('-h', '--help'):

            usage(0)

            # does not return

        elif arg in ('-g', '--gain'):

            gainspec = '<missing>'

            try:

                gainspec = sys.argv[i+1]

                gain = int(gainspec)

            except (ValueError, IndexError):

                usage(1, 'Bad gain specification: ' + gainspec)

            info.o_gain = gain

            i = i + 1

            continue

        elif arg in ('-v', '--version'):

            print '''\

audiopy -- a program to control the Solaris audio device.

Contact: Barry Warsaw

Email:   bwarsaw@python.org

Version: %s''' % __version__            

            sys.exit(0)

        for long, short, io, mask in options:

            if arg in (long, short):

                # toggle the option

                if io == 0: 

                    info.i_port = info.i_port ^ mask

                else:

                    info.o_port = info.o_port ^ mask

                break

            val = None

            try:

                if arg[:len(long)+1] == long+'=':

                    val = int(arg[len(long)+1:])

                elif arg[:len(short)+1] == short+'=':

                    val = int(arg[len(short)+1:])

            except ValueError:

                usage(1, msg='Invalid option: ' + arg)

                # does not return

            if val == 0:

                if io == 0:

                    info.i_port = info.i_port & ~mask

                else:

                    info.o_port = info.o_port & ~mask

                break

            elif val == 1:

                if io == 0:

                    info.i_port = info.i_port | mask

                else:

                    info.o_port = info.o_port | mask

                break

            # else keep trying next option

        else:

            usage(1, msg='Invalid option: ' + arg)

    # now set the values

    try:

        device.setinfo(info)

    except sunaudiodev.error, (code, msg):

        if code <> errno.EINVAL:

            raise

    device.close()

if __name__ == '__main__':

    main()