xref: /external/python/cpython2/Tools/audiopy/audiopy

#! /usr/bin/env python

"""Program to control the Solaris audio device.

When no arguments are given, this pops up a graphical window which lets you
choose which audio output device you want sound to go to.

This program can be driven via the command line, and when done so, no window
pops up.  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:

    --help
    -h
        Print this message and exit.

"""

import sys
from Tkinter import *
import sunaudiodev
from SUNAUDIODEV import *

# Milliseconds between interrupt checks
KEEPALIVE_TIMER = 500



class MainWindow:
    def __init__(self, device):
        self.__devctl = device
        info = device.getinfo()
        #
        self.__tkroot = tkroot = Tk(className='Pynche')
        tkroot.withdraw()
        # now create the top level window
        root = self.__root = Toplevel(tkroot, class_='Audiopy')
        root.protocol('WM_DELETE_WINDOW', self.__quit)
        root.title('Audiopy')
        root.iconname('Audiopy')
        root.tk.createtimerhandler(KEEPALIVE_TIMER, self.__keepalive)
        #
        buttons = []
        #
        # where does input come from?
        frame = Frame(root, bd=1, relief=RAISED)
        frame.grid(row=0, column=0)
        label = Label(frame, text='Input From:')
        label.grid(row=0, column=0, sticky=E)
        self.__micvar = IntVar()
        btn = Checkbutton(frame,
                          text='Microphone',
                          variable=self.__micvar,
                          onvalue=MICROPHONE,
                          command=self.__pushtodev,
                          underline=0)
        btn.grid(row=0, 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)
        ##
        self.__lineinvar = IntVar()
        btn = Checkbutton(frame,
                          text='Line In',
                          variable=self.__lineinvar,
                          onvalue=LINE_IN,
                          command=self.__pushtodev,
                          underline=5)
        btn.grid(row=1, 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)
        ##
        self.__cdvar = IntVar()
        btn = Checkbutton(frame,
                          text='CD',
                          variable=self.__cdvar,
                          onvalue=CD,
                          command=self.__pushtodev,
                          underline=0)
        btn.grid(row=2, 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)
        #
        # where does output go to?
        frame = Frame(root, bd=1, relief=RAISED)
        frame.grid(row=1, column=0)
        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=0)
        btn.grid(row=1, column=1, sticky=W)
        root.bind('<Alt-h>', self.__headphones)
        root.bind('<Alt-H>', 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)
        #
        # Add quit button
        frame = Frame(root)
        frame.grid(row=2, column=0, sticky='EW', ipady=5)
        btn = Button(frame,
                     text='Quit',
                     command=self.__quit,
                     underline=0)
        btn.pack(expand=YES)
        root.bind('<Alt-q>', self.__quit)
        root.bind('<Alt-Q>', self.__quit)
        #
        # do we need to poll for changes?
        self.__needtopoll = 1
        try:
            fd = self.__devctl.fileno()
            self.__needtopoll = 0
        except AttributeError:
            pass
        else:
            import struct
            import fcntl
            import signal
            import FCNTL
            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 __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):
        # We have to poll because the device could have changed state and the
        # underlying module does not support the SIGPOLL notification
        # interface.
        info = self.__devctl.getinfo()
        self.__spkvar.set(info.o_port & SPEAKER)
        self.__headvar.set(info.o_port & HEADPHONE)
        self.__linevar.set(info.o_port & LINE_OUT)
        self.__micvar.set(info.i_port & MICROPHONE)
        self.__lineinvar.set(info.i_port & LINE_IN)
        self.__cdvar.set(info.i_port & CD)

    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.__micvar.get() + \
                      self.__lineinvar.get() + \
                      self.__cdvar.get()
        self.__devctl.setinfo(info)

    def __getset(self, var, onvalue):
        if var.get():
            var.set(0)
        else:
            var.set(onvalue)
        self.__pushtodev()

    def __mic(self, event=None):
        self.__getset(self.__micvar, MICROPHONE)

    def __linein(self, event=None):
        self.__getset(self.__lineinvar, LINE_IN)

    def __cd(self, event=None):
        print 'pre:', self.__cdvar.get()
        self.__getset(self.__cdvar, CD)
        print 'post:', self.__cdvar.get()

    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 start(self):
        self.__keepalive()
        self.__tkroot.mainloop()



def usage(msg='', code=1):
    print __doc__
    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),
               ('--cd',         '-c', 0, CD),
               ('--headphones', '-p', 1, HEADPHONE),
               ('--speaker',    '-s', 1, SPEAKER),
               ('--lineout',    '-o', 1, LINE_OUT),
               )
    values = []
    info = device.getinfo()
    # first get the existing values
    for long, short, io, mask in options:
        if io == 0:
            flags = info.i_port
        else:
            flags = info.o_port
        values.append(flags & mask)

    sval = None
    hval = None
    lval = None
    for arg in sys.argv[1:]:
        if arg in ('-h', '--help'):
            usage(code=0)
        # SPEAKER
        elif arg in ('-s', '--speaker'):
            sval = -1
        elif arg[:3] == '-s=':
            try:
                sval = int(arg[3:])
            except ValueError:
                pass
            if sval <> 0 and sval <> 1:
                usage('Invalid option: ' + arg)
        elif arg[:10] == '--speaker=':
            try:
                sval = int(arg[10:])
            except ValueError:
                pass
            if sval <> 0 and sval <> 1:
                usage('Invalid option: ' + arg)
        # HEADPHONES
        elif arg in ('-p', '--headphones'):
            hval = -1
        elif arg[:3] == '-p=':
            try:
                hval = int(arg[3:])
            except ValueError:
                pass
            if hval <> 0 and hval <> 1:
                usage('Invalid option: ' + arg)
        elif arg[:13] == '--headphones=':
            try:
                hval = int(arg[130:])
            except ValueError:
                pass
            if hval <> 0 and hval <> 1:
                usage('Invalid option: ' + arg)
        # LINEOUT
        elif arg in ('-l', '--lineout'):
            lval = -1
        elif arg[:3] == '-l=':
            try:
                lval = int(arg[3:])
            except ValueError:
                pass
            if lval <> 0 and lval <> 1:
                usage('Invalid option: ' + arg)
        elif arg[:10] == '--lineout=':
            try:
                lval = int(arg[10:])
            except ValueError:
                pass
            if lval <> 0 and lval <> 1:
                usage('Invalid option: ' + arg)
        else:
            usage('Invalid option: ' + arg)
    # now set the values
    try:
        devctl = sunaudiodev.open('control')
        info = devctl.getinfo()
        if sval is not None:
            if sval == -1:
                if info.o_port & SPEAKER:
                    sval = 0
                else:
                    sval = SPEAKER
            else:
                sval = sval * SPEAKER
        else:
            sval = info.o_port & SPEAKER
        if hval is not None:
            if hval == -1:
                if info.o_port & HEADPHONE:
                    hval = 0
                else:
                    hval = HEADPHONE
            else:
                hval = hval * HEADPHONE
        else:
            hval = info.o_port & HEADPHONE
        if lval is not None:
            if lval == -1:
                if info.o_port & LINE_OUT:
                    lval = 0
                else:
                    lval = LINE_OUT
            else:
                lval = lval * LINE_OUT
        else:
            lval = info.o_port & LINE_OUT
        info.o_port = sval + hval + lval
        devctl.setinfo(info)
    finally:
        devctl.close()
            


if __name__ == '__main__':
    main()