home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / audiodev.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  7.6 KB  |  284 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  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.         self.oldparams = []
  48.         self.params = [
  49.             AL.OUTPUT_RATE,
  50.             0]
  51.         self.config = al.newconfig()
  52.         self.inited_outrate = 0
  53.         self.inited_width = 0
  54.         self.inited_nchannels = 0
  55.         self.converter = None
  56.         self.port = None
  57.  
  58.     
  59.     def __del__(self):
  60.         if self.port:
  61.             self.stop()
  62.         if self.oldparams:
  63.             import al
  64.             import AL
  65.             al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
  66.             self.oldparams = []
  67.  
  68.     
  69.     def wait(self):
  70.         if not self.port:
  71.             return None
  72.         import time
  73.         while self.port.getfilled() > 0:
  74.             time.sleep(0.1)
  75.         self.stop()
  76.  
  77.     
  78.     def stop(self):
  79.         if self.port:
  80.             self.port.closeport()
  81.             self.port = None
  82.         if self.oldparams:
  83.             import al
  84.             import AL
  85.             al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
  86.             self.oldparams = []
  87.  
  88.     
  89.     def setoutrate(self, rate):
  90.         for raw, cooked in self.frameratelist:
  91.             if rate == raw:
  92.                 self.params[1] = cooked
  93.                 self.inited_outrate = 1
  94.                 break
  95.                 continue
  96.             raise error, 'bad output rate'
  97.             return None
  98.  
  99.     
  100.     def setsampwidth(self, width):
  101.         for raw, cooked in self.sampwidthlist:
  102.             if width == raw:
  103.                 self.config.setwidth(cooked)
  104.                 self.inited_width = 1
  105.                 break
  106.                 continue
  107.             if width == 0:
  108.                 import AL
  109.                 self.inited_width = 0
  110.                 self.config.setwidth(AL.SAMPLE_16)
  111.                 self.converter = self.ulaw2lin
  112.             else:
  113.                 raise error, 'bad sample width'
  114.             return None
  115.  
  116.     
  117.     def setnchannels(self, nchannels):
  118.         for raw, cooked in self.nchannelslist:
  119.             if nchannels == raw:
  120.                 self.config.setchannels(cooked)
  121.                 self.inited_nchannels = 1
  122.                 break
  123.                 continue
  124.             raise error, 'bad # of channels'
  125.             return None
  126.  
  127.     
  128.     def writeframes(self, data):
  129.         if not self.inited_outrate and self.inited_nchannels:
  130.             raise error, 'params not specified'
  131.         if not self.port:
  132.             import al
  133.             import AL
  134.             self.port = al.openport('Python', 'w', self.config)
  135.             self.oldparams = self.params[:]
  136.             al.getparams(AL.DEFAULT_DEVICE, self.oldparams)
  137.             al.setparams(AL.DEFAULT_DEVICE, self.params)
  138.         if self.converter:
  139.             data = self.converter(data)
  140.         self.port.writesamps(data)
  141.  
  142.     
  143.     def getfilled(self):
  144.         if self.port:
  145.             return self.port.getfilled()
  146.         return None
  147.  
  148.     
  149.     def getfillable(self):
  150.         if self.port:
  151.             return self.port.getfillable()
  152.         return None.config.getqueuesize()
  153.  
  154.     
  155.     def ulaw2lin(self, data):
  156.         import audioop
  157.         return audioop.ulaw2lin(data, 2)
  158.  
  159.  
  160.  
  161. class Play_Audio_sun:
  162.     
  163.     def __init__(self):
  164.         self.outrate = 0
  165.         self.sampwidth = 0
  166.         self.nchannels = 0
  167.         self.inited_outrate = 0
  168.         self.inited_width = 0
  169.         self.inited_nchannels = 0
  170.         self.converter = None
  171.         self.port = None
  172.  
  173.     
  174.     def __del__(self):
  175.         self.stop()
  176.  
  177.     
  178.     def setoutrate(self, rate):
  179.         self.outrate = rate
  180.         self.inited_outrate = 1
  181.  
  182.     
  183.     def setsampwidth(self, width):
  184.         self.sampwidth = width
  185.         self.inited_width = 1
  186.  
  187.     
  188.     def setnchannels(self, nchannels):
  189.         self.nchannels = nchannels
  190.         self.inited_nchannels = 1
  191.  
  192.     
  193.     def writeframes(self, data):
  194.         if not self.inited_outrate and self.inited_width and self.inited_nchannels:
  195.             raise error, 'params not specified'
  196.         if not self.port:
  197.             import sunaudiodev
  198.             import SUNAUDIODEV
  199.             self.port = sunaudiodev.open('w')
  200.             info = self.port.getinfo()
  201.             info.o_sample_rate = self.outrate
  202.             info.o_channels = self.nchannels
  203.             if self.sampwidth == 0:
  204.                 info.o_precision = 8
  205.                 self.o_encoding = SUNAUDIODEV.ENCODING_ULAW
  206.             else:
  207.                 info.o_precision = 8 * self.sampwidth
  208.                 info.o_encoding = SUNAUDIODEV.ENCODING_LINEAR
  209.                 self.port.setinfo(info)
  210.         if self.converter:
  211.             data = self.converter(data)
  212.         self.port.write(data)
  213.  
  214.     
  215.     def wait(self):
  216.         if not self.port:
  217.             return None
  218.         None.port.drain()
  219.         self.stop()
  220.  
  221.     
  222.     def stop(self):
  223.         if self.port:
  224.             self.port.flush()
  225.             self.port.close()
  226.             self.port = None
  227.  
  228.     
  229.     def getfilled(self):
  230.         if self.port:
  231.             return self.port.obufcount()
  232.         return None
  233.  
  234.  
  235.  
  236. def AudioDev():
  237.     
  238.     try:
  239.         import al
  240.     except ImportError:
  241.         
  242.         try:
  243.             import sunaudiodev
  244.             return Play_Audio_sun()
  245.         except ImportError:
  246.             
  247.             try:
  248.                 import Audio_mac
  249.             except ImportError:
  250.                 raise error, 'no audio device'
  251.  
  252.             return Audio_mac.Play_Audio_mac()
  253.         
  254.  
  255.  
  256.     return Play_Audio_sgi()
  257.  
  258.  
  259. def test(fn = None):
  260.     import sys
  261.     if sys.argv[1:]:
  262.         fn = sys.argv[1]
  263.     else:
  264.         fn = 'f:just samples:just.aif'
  265.     import aifc
  266.     af = aifc.open(fn, 'r')
  267.     print fn, af.getparams()
  268.     p = AudioDev()
  269.     p.setoutrate(af.getframerate())
  270.     p.setsampwidth(af.getsampwidth())
  271.     p.setnchannels(af.getnchannels())
  272.     BUFSIZ = af.getframerate() / af.getsampwidth() / af.getnchannels()
  273.     while None:
  274.         data = af.readframes(BUFSIZ)
  275.         if not data:
  276.             break
  277.         print len(data)
  278.         continue
  279.         p.wait()
  280.         return None
  281.  
  282. if __name__ == '__main__':
  283.     test()
  284.