home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_268 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  7.7 KB  |  302 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from warnings import warnpy3k
  5. warnpy3k('the audiodev module has been removed in Python 3.0', stacklevel = 2)
  6. del warnpy3k
  7. __all__ = [
  8.     'error',
  9.     'AudioDev']
  10.  
  11. class error(Exception):
  12.     pass
  13.  
  14.  
  15. class Play_Audio_sgi:
  16.     classinited = 0
  17.     frameratelist = None
  18.     nchannelslist = None
  19.     sampwidthlist = None
  20.     
  21.     def initclass(self):
  22.         import AL
  23.         self.frameratelist = [
  24.             (48000, AL.RATE_48000),
  25.             (44100, AL.RATE_44100),
  26.             (32000, AL.RATE_32000),
  27.             (22050, AL.RATE_22050),
  28.             (16000, AL.RATE_16000),
  29.             (11025, AL.RATE_11025),
  30.             (8000, AL.RATE_8000)]
  31.         self.nchannelslist = [
  32.             (1, AL.MONO),
  33.             (2, AL.STEREO),
  34.             (4, AL.QUADRO)]
  35.         self.sampwidthlist = [
  36.             (1, AL.SAMPLE_8),
  37.             (2, AL.SAMPLE_16),
  38.             (3, AL.SAMPLE_24)]
  39.         self.classinited = 1
  40.  
  41.     
  42.     def __init__(self):
  43.         import al
  44.         import AL
  45.         if not self.classinited:
  46.             self.initclass()
  47.         
  48.         self.oldparams = []
  49.         self.params = [
  50.             AL.OUTPUT_RATE,
  51.             0]
  52.         self.config = al.newconfig()
  53.         self.inited_outrate = 0
  54.         self.inited_width = 0
  55.         self.inited_nchannels = 0
  56.         self.converter = None
  57.         self.port = None
  58.  
  59.     
  60.     def __del__(self):
  61.         if self.port:
  62.             self.stop()
  63.         
  64.         if self.oldparams:
  65.             import al
  66.             import AL
  67.             al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
  68.             self.oldparams = []
  69.         
  70.  
  71.     
  72.     def wait(self):
  73.         if not self.port:
  74.             return None
  75.         import time
  76.         while self.port.getfilled() > 0:
  77.             time.sleep(0.1)
  78.             continue
  79.             self.port
  80.         self.stop()
  81.  
  82.     
  83.     def stop(self):
  84.         if self.port:
  85.             self.port.closeport()
  86.             self.port = None
  87.         
  88.         if self.oldparams:
  89.             import al
  90.             import AL
  91.             al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
  92.             self.oldparams = []
  93.         
  94.  
  95.     
  96.     def setoutrate(self, rate):
  97.         for raw, cooked in self.frameratelist:
  98.             if rate == raw:
  99.                 self.params[1] = cooked
  100.                 self.inited_outrate = 1
  101.                 break
  102.                 continue
  103.         else:
  104.             raise error, 'bad output rate'
  105.  
  106.     
  107.     def setsampwidth(self, width):
  108.         for raw, cooked in self.sampwidthlist:
  109.             if width == raw:
  110.                 self.config.setwidth(cooked)
  111.                 self.inited_width = 1
  112.                 break
  113.                 continue
  114.         elif width == 0:
  115.             import AL
  116.             self.inited_width = 0
  117.             self.config.setwidth(AL.SAMPLE_16)
  118.             self.converter = self.ulaw2lin
  119.         else:
  120.             raise error, 'bad sample width'
  121.  
  122.     
  123.     def setnchannels(self, nchannels):
  124.         for raw, cooked in self.nchannelslist:
  125.             if nchannels == raw:
  126.                 self.config.setchannels(cooked)
  127.                 self.inited_nchannels = 1
  128.                 break
  129.                 continue
  130.         else:
  131.             raise error, 'bad # of channels'
  132.  
  133.     
  134.     def writeframes(self, data):
  135.         if not self.inited_outrate and self.inited_nchannels:
  136.             raise error, 'params not specified'
  137.         self.inited_nchannels
  138.         if not self.port:
  139.             import al
  140.             import AL
  141.             self.port = al.openport('Python', 'w', self.config)
  142.             self.oldparams = self.params[:]
  143.             al.getparams(AL.DEFAULT_DEVICE, self.oldparams)
  144.             al.setparams(AL.DEFAULT_DEVICE, self.params)
  145.         
  146.         if self.converter:
  147.             data = self.converter(data)
  148.         
  149.         self.port.writesamps(data)
  150.  
  151.     
  152.     def getfilled(self):
  153.         if self.port:
  154.             return self.port.getfilled()
  155.         return 0
  156.  
  157.     
  158.     def getfillable(self):
  159.         if self.port:
  160.             return self.port.getfillable()
  161.         return self.config.getqueuesize()
  162.  
  163.     
  164.     def ulaw2lin(self, data):
  165.         import audioop
  166.         return audioop.ulaw2lin(data, 2)
  167.  
  168.  
  169.  
  170. class Play_Audio_sun:
  171.     
  172.     def __init__(self):
  173.         self.outrate = 0
  174.         self.sampwidth = 0
  175.         self.nchannels = 0
  176.         self.inited_outrate = 0
  177.         self.inited_width = 0
  178.         self.inited_nchannels = 0
  179.         self.converter = None
  180.         self.port = None
  181.  
  182.     
  183.     def __del__(self):
  184.         self.stop()
  185.  
  186.     
  187.     def setoutrate(self, rate):
  188.         self.outrate = rate
  189.         self.inited_outrate = 1
  190.  
  191.     
  192.     def setsampwidth(self, width):
  193.         self.sampwidth = width
  194.         self.inited_width = 1
  195.  
  196.     
  197.     def setnchannels(self, nchannels):
  198.         self.nchannels = nchannels
  199.         self.inited_nchannels = 1
  200.  
  201.     
  202.     def writeframes(self, data):
  203.         if not self.inited_outrate and self.inited_width and self.inited_nchannels:
  204.             raise error, 'params not specified'
  205.         self.inited_nchannels
  206.         if not self.port:
  207.             import sunaudiodev
  208.             import SUNAUDIODEV
  209.             self.port = sunaudiodev.open('w')
  210.             info = self.port.getinfo()
  211.             info.o_sample_rate = self.outrate
  212.             info.o_channels = self.nchannels
  213.             if self.sampwidth == 0:
  214.                 info.o_precision = 8
  215.                 self.o_encoding = SUNAUDIODEV.ENCODING_ULAW
  216.             else:
  217.                 info.o_precision = 8 * self.sampwidth
  218.                 info.o_encoding = SUNAUDIODEV.ENCODING_LINEAR
  219.                 self.port.setinfo(info)
  220.         
  221.         if self.converter:
  222.             data = self.converter(data)
  223.         
  224.         self.port.write(data)
  225.  
  226.     
  227.     def wait(self):
  228.         if not self.port:
  229.             return None
  230.         self.port.drain()
  231.         self.stop()
  232.  
  233.     
  234.     def stop(self):
  235.         if self.port:
  236.             self.port.flush()
  237.             self.port.close()
  238.             self.port = None
  239.         
  240.  
  241.     
  242.     def getfilled(self):
  243.         if self.port:
  244.             return self.port.obufcount()
  245.         return 0
  246.  
  247.  
  248.  
  249. def AudioDev():
  250.     
  251.     try:
  252.         import al
  253.     except ImportError:
  254.         
  255.         try:
  256.             import sunaudiodev
  257.             return Play_Audio_sun()
  258.         except ImportError:
  259.             
  260.             try:
  261.                 import Audio_mac
  262.             except ImportError:
  263.                 raise error, 'no audio device'
  264.  
  265.             return Audio_mac.Play_Audio_mac()
  266.         except:
  267.             None<EXCEPTION MATCH>ImportError
  268.         
  269.  
  270.         None<EXCEPTION MATCH>ImportError
  271.  
  272.     return Play_Audio_sgi()
  273.  
  274.  
  275. def test(fn = None):
  276.     import sys
  277.     if sys.argv[1:]:
  278.         fn = sys.argv[1]
  279.     else:
  280.         fn = 'f:just samples:just.aif'
  281.     import aifc
  282.     af = aifc.open(fn, 'r')
  283.     print fn, af.getparams()
  284.     p = AudioDev()
  285.     p.setoutrate(af.getframerate())
  286.     p.setsampwidth(af.getsampwidth())
  287.     p.setnchannels(af.getnchannels())
  288.     BUFSIZ = af.getframerate() / af.getsampwidth() / af.getnchannels()
  289.     while None:
  290.         data = af.readframes(BUFSIZ)
  291.         if not data:
  292.             break
  293.         
  294.         print len(data)
  295.         continue
  296.         p.wait()
  297.         return None
  298.  
  299. if __name__ == '__main__':
  300.     test()
  301.  
  302.