home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pyth_os2.zip / python-1.0.2 / Demo / sgi / dal / dald.py < prev    next >
Encoding:
Python Source  |  1994-01-07  |  5.6 KB  |  215 lines
  1. # Server for Distributed Audio Library.
  2.  
  3. # Start this manually when you log in after starting your X server.
  4.  
  5. # CAVEAT: The server does not do any authorization checking.  Once you
  6. # start the DAL server, anyone with a DAL client can manipulate your
  7. # audio device.  You have been warned!
  8.  
  9. # XXX error returns are bogus!
  10.  
  11.  
  12. import sys
  13. sys.path.append('/ufs/guido/src/python/new/Demo/rpc')
  14. import al
  15. import AL
  16. import rpc
  17. from dalxdr import *
  18.  
  19.  
  20. class DALServer(rpc.TCPServer):
  21.  
  22.     def __init__(self):
  23.         rpc.TCPServer.__init__(self, '', 0x25924127, 1, 0)
  24.     def addpackers(self):
  25.         self.packer = DALPacker()
  26.         self.unpacker = DALUnpacker('')
  27.  
  28.     def session(self, connection):
  29.         self.all_ports = []
  30.         try:
  31.             rpc.TCPServer.session(self, connection)
  32.         finally:
  33.             all_ports = self.all_ports
  34.             del self.all_ports
  35.             for p in all_ports:
  36.                 if p: p.closeport()
  37.     def getport(self, index):
  38.         if not 0 <= index < len(self.all_ports):
  39.             return None
  40.         return self.all_ports[index]
  41.  
  42.     def handle_1(self): # queryparams
  43.         dev = self.unpacker.unpack_int()
  44.         self.turn_around()
  45. ##        print 'queryparams:', dev
  46.         params = al.queryparams(dev)
  47. ##        print 'queryparams ->', params
  48.         self.packer.pack_params(params)
  49.     def handle_2(self): # getparams
  50.         dev, params = self.unpacker.unpack_int_params()
  51.         self.turn_around()
  52. ##        print 'getparams:', dev, params
  53.         al.getparams(dev, params)
  54. ##        print 'getparams ->', params
  55.         self.packer.pack_params(params)
  56.     def handle_3(self): # setparams
  57.         dev, params = self.unpacker.unpack_int_params()
  58.         self.turn_around()
  59. ##        print 'setparams:', dev, params
  60.         al.setparams(dev, params)
  61.     def handle_4(self): # getname
  62.         dev, descr = self.unpacker.unpack_int_int()
  63.         self.turn_around()
  64. ##        print 'getname:', dev, descr
  65.         self.packer.pack_string(al.getname(dev, descr))
  66.     def handle_5(self): # getdefault
  67.         dev, descr = self.unpacker.unpack_int_int()
  68.         self.turn_around()
  69. ##        print 'getdefault:', dev, descr
  70.         self.packer.pack_int(al.getdefault(dev, descr))
  71.     def handle_6(self): # getminmax
  72.         dev, descr = self.unpacker.unpack_int_int()
  73.         self.turn_around()
  74. ##        print 'getminmax:', dev, descr
  75.         self.packer.pack_int_int(al.getminmax(dev, descr))
  76.  
  77.     def handle_11(self): # openport
  78.         name, mode, config_flat = self.unpacker.unpack_openport()
  79.         self.turn_around()
  80. ##        print 'openport:', name, mode, config_flat
  81.         queuesize, width, channels, sampfmt, floatmax = config_flat
  82.         try:
  83.             c = al.newconfig()
  84.             c.setqueuesize(queuesize)
  85.             c.setwidth(width)
  86.             c.setchannels(channels)
  87.             c.setsampfmt(sampfmt)
  88.             c.setfloatmax(floatmax)
  89.             p = al.openport(name, mode, c)
  90.         except RuntimeError:
  91.             self.packer.pack_int(-1) # Should get error code?
  92.             return
  93.         for i in range(len(self.all_ports)):
  94.             if self.all_ports[i] is None:
  95.                 self.all_ports[i] = p
  96.                 break
  97.         else:
  98.             i = len(self.all_ports)
  99.             self.all_ports.append(p)
  100. ##        print 'openport ->', i
  101.         self.packer.pack_int(i)
  102.     def handle_12(self): # closeport
  103.         i = self.unpacker.unpack_int()
  104.         self.turn_around()
  105. ##        print 'closeport:', i
  106.         p = self.getport(i)
  107.         if p is None:
  108.             return
  109.         p.closeport()
  110.         self.all_ports[i] = None
  111.     def handle_13(self): # getfilled
  112.         i = self.unpacker.unpack_int()
  113.         self.turn_around()
  114. ##        print 'getfilled:', i
  115.         p = self.getport(i)
  116.         if p is None:
  117.             return
  118.         self.packer.pack_int(p.getfilled())
  119.     def handle_14(self): # getfillable
  120.         i = self.unpacker.unpack_int()
  121.         self.turn_around()
  122. ##        print 'getfillable:', i
  123.         p = self.getport(i)
  124.         if p is None:
  125.             return
  126.         self.packer.pack_int(p.getfillable())
  127.     def handle_15(self): # readsamps
  128.         i, n = self.unpacker.unpack_readsamps()
  129.         self.turn_around()
  130. ##        print 'readsamps:', i, n
  131.         p = self.getport(i)
  132.         if p is None:
  133.             return
  134.         buffer = p.readsamps(n)
  135.         self.packer.pack_string(buffer)
  136.     def handle_16(self): # writesamps
  137.         i, buffer = self.unpacker.unpack_writesamps()
  138.         self.turn_around()
  139. ##        print 'writesamps:', i, len(buffer)
  140.         p = self.getport(i)
  141.         if p is None:
  142.             return
  143.         p.writesamps(buffer)
  144.     def handle_17(self): # getfillpoint
  145.         i = self.unpacker.unpack_int()
  146.         self.turn_around()
  147. ##        print 'getfillpoint:', i
  148.         p = self.getport(i)
  149.         if p is None:
  150.             return
  151.         self.packer.pack_int(p.getfillpoint())
  152.     def handle_18(self): # setfillpoint
  153.         i = self.unpacker.unpack_int()
  154.         fillpoint = self.unpacker.unpack_int()
  155.         self.turn_around()
  156. ##        print 'setfillpoint:', i, fillpoint
  157.         p = self.getport(i)
  158.         if p is None:
  159.             return
  160.         p.setfillpoint(fillpoint)
  161.     def handle_19(self): # getconfig
  162.         i = self.unpacker.unpack_int()
  163.         self.turn_around()
  164. ##        print 'getconfig:', i
  165.         p = self.getport(i)
  166.         if p is None:
  167.             return
  168.         c = p.getconfig()
  169.         config_flat = c.getqueuesize(), c.getwidth(), \
  170.                   c.getchannels(), c.getsampfmt(), c.getfloatmax()
  171.         self.packer.pack_config(config_flat)
  172.     def handle_20(self): # setconfig
  173.         i = self.unpacker.unpack_int()
  174.         config_flat = self.unpacker.unpack_config()
  175.         self.turn_around()
  176. ##        print 'setconfig:', i, config_flat
  177.         p = self.getport(i)
  178.         if p is None:
  179.             return
  180.         queuesize, width, channels, sampfmt, floatmax = config_flat
  181.         c = al.newconfig()
  182.         # (You can't change queuesize and channels of an open port)
  183.         # c.setqueuesize(queuesize)
  184.         c.setwidth(width)
  185.         # c.setchannels(channels)
  186.         c.setsampfmt(sampfmt)
  187.         c.setfloatmax(floatmax)
  188.         p.setconfig(c)
  189.     def handle_21(self): # getstatus
  190.         i = self.unpacker.unpack_int()
  191.         params = self.unpacker.unpack_params()
  192.         self.turn_around()
  193. ##        print 'getstatus:', i, params
  194.         p = self.getport(i)
  195.         if p is None:
  196.             return
  197.         p.getstatus(params)
  198.         self.packer.pack_params(params)
  199.  
  200.  
  201. def main():
  202.     s = DALServer()
  203.     s.register()
  204.     print 'DAL server starting...'
  205.     try:
  206.         try:
  207.             s.forkingloop()
  208.         except KeyboardInterrupt:
  209.             print 'DAL server interrupted.'
  210.     finally:
  211.         s.unregister()
  212.  
  213.  
  214. main()
  215.