Lib/audiodev.py

   1 error = 'audiodev.error'
   2
   3 class Play_Audio_sgi:
   4         # Private instance variables
   5 ##      if 0: access frameratelist, nchannelslist, sampwidthlist, oldparams, \
   6 ##                params, config, inited_outrate, inited_width, \
   7 ##                inited_nchannels, port, converter, classinited: private
   8
   9         classinited = 0
  10         frameratelist = nchannelslist = sampwidthlist = None
  11
  12         def initclass(self):
  13                 import AL
  14                 self.frameratelist = [
  15                           (48000, AL.RATE_48000),
  16                           (44100, AL.RATE_44100),
  17                           (32000, AL.RATE_32000),
  18                           (22050, AL.RATE_22050),
  19                           (16000, AL.RATE_16000),
  20                           (11025, AL.RATE_11025),
  21                           ( 8000,  AL.RATE_8000),
  22                           ]
  23                 self.nchannelslist = [
  24                           (1, AL.MONO),
  25                           (2, AL.STEREO),
  26                           (4, AL.QUADRO),
  27                           ]
  28                 self.sampwidthlist = [
  29                           (1, AL.SAMPLE_8),
  30                           (2, AL.SAMPLE_16),
  31                           (3, AL.SAMPLE_24),
  32                           ]
  33                 self.classinited = 1
  34
  35         def __init__(self):
  36                 import al, AL
  37                 if not self.classinited:
  38                         self.initclass()
  39                 self.oldparams = []
  40                 self.params = [AL.OUTPUT_RATE, 0]
  41                 self.config = al.newconfig()
  42                 self.inited_outrate = 0
  43                 self.inited_width = 0
  44                 self.inited_nchannels = 0
  45                 self.converter = None
  46                 self.port = None
  47                 return
  48
  49         def __del__(self):
  50                 if self.port:
  51                         self.stop()
  52                 if self.oldparams:
  53                         import al, AL
  54                         al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
  55                         self.oldparams = []
  56
  57         def wait(self):
  58                 if not self.port:
  59                         return
  60                 import time
  61                 while self.port.getfilled() > 0:
  62                         time.sleep(0.1)
  63                 self.stop()
  64
  65         def stop(self):
  66                 if self.port:
  67                         self.port.closeport()
  68                         self.port = None
  69                 if self.oldparams:
  70                         import al, AL
  71                         al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
  72                         self.oldparams = []
  73
  74         def setoutrate(self, rate):
  75                 for (raw, cooked) in self.frameratelist:
  76                         if rate == raw:
  77                                 self.params[1] = cooked
  78                                 self.inited_outrate = 1
  79                                 break
  80                 else:
  81                         raise error, 'bad output rate'
  82
  83         def setsampwidth(self, width):
  84                 for (raw, cooked) in self.sampwidthlist:
  85                         if width == raw:
  86                                 self.config.setwidth(cooked)
  87                                 self.inited_width = 1
  88                                 break
  89                 else:
  90                         if width == 0:
  91                                 import AL
  92                                 self.inited_width = 0
  93                                 self.config.setwidth(AL.SAMPLE_16)
  94                                 self.converter = self.ulaw2lin
  95                         else:
  96                                 raise error, 'bad sample width'
  97
  98         def setnchannels(self, nchannels):
  99                 for (raw, cooked) in self.nchannelslist:
 100                         if nchannels == raw:
 101                                 self.config.setchannels(cooked)
 102                                 self.inited_nchannels = 1
 103                                 break
 104                 else:
 105                         raise error, 'bad # of channels'
 106
 107         def writeframes(self, data):
 108                 if not (self.inited_outrate and self.inited_nchannels):
 109                         raise error, 'params not specified'
 110                 if not self.port:
 111                         import al, AL
 112                         self.port = al.openport('Python', 'w', self.config)
 113                         self.oldparams = self.params[:]
 114                         al.getparams(AL.DEFAULT_DEVICE, self.oldparams)
 115                         al.setparams(AL.DEFAULT_DEVICE, self.params)
 116                 if self.converter:
 117                         data = self.converter(data)
 118                 self.port.writesamps(data)
 119
 120         def getfilled(self):
 121                 if self.port:
 122                         return self.port.getfilled()
 123                 else:
 124                         return 0
 125
 126         def getfillable(self):
 127                 if self.port:
 128                         return self.port.getfillable()
 129                 else:
 130                         return self.config.getqueuesize()
 131
 132         # private methods
 133 ##      if 0: access *: private
 134
 135         def ulaw2lin(self, data):
 136                 import audioop
 137                 return audioop.ulaw2lin(data, 2)
 138
 139 class Play_Audio_sun:
 140 ##      if 0: access outrate, sampwidth, nchannels, inited_outrate, inited_width, \
 141 ##                inited_nchannels, converter: private
 142
 143         def __init__(self):
 144                 self.outrate = 0
 145                 self.sampwidth = 0
 146                 self.nchannels = 0
 147                 self.inited_outrate = 0
 148                 self.inited_width = 0
 149                 self.inited_nchannels = 0
 150                 self.converter = None
 151                 self.port = None
 152                 return
 153
 154         def __del__(self):
 155                 self.stop()
 156
 157         def setoutrate(self, rate):
 158                 self.outrate = rate
 159                 self.inited_outrate = 1
 160
 161         def setsampwidth(self, width):
 162                 self.sampwidth = width
 163                 self.inited_width = 1
 164
 165         def setnchannels(self, nchannels):
 166                 self.nchannels = nchannels
 167                 self.inited_nchannels = 1
 168
 169         def writeframes(self, data):
 170                 if not (self.inited_outrate and self.inited_width and self.inited_nchannels):
 171                         raise error, 'params not specified'
 172                 if not self.port:
 173                         import sunaudiodev, SUNAUDIODEV
 174                         self.port = sunaudiodev.open('w')
 175                         info = self.port.getinfo()
 176                         info.o_sample_rate = self.outrate
 177                         info.o_channels = self.nchannels
 178                         if self.sampwidth == 0:
 179                                 info.o_precision = 8
 180                                 self.o_encoding = SUNAUDIODEV.ENCODING_ULAW
 181                                 # XXX Hack, hack -- leave defaults
 182                         else:
 183                                 info.o_precision = 8 * self.sampwidth
 184                                 info.o_encoding = SUNAUDIODEV.ENCODING_LINEAR
 185                                 self.port.setinfo(info)
 186                 if self.converter:
 187                         data = self.converter(data)
 188                 self.port.write(data)
 189
 190         def wait(self):
 191                 if not self.port:
 192                         return
 193                 self.port.drain()
 194                 self.stop()
 195
 196         def stop(self):
 197                 if self.port:
 198                         self.port.flush()
 199                         self.port.close()
 200                         self.port = None
 201
 202         def getfilled(self):
 203                 if self.port:
 204                         return self.port.obufcount()
 205                 else:
 206                         return 0
 207
 208         def getfillable(self):
 209                 return BUFFERSIZE - self.getfilled()
 210
 211 def AudioDev():
 212         # Dynamically try to import and use a platform specific module.
 213         try:
 214                 import al
 215         except ImportError:
 216                 try:
 217                         import sunaudiodev
 218                         return Play_Audio_sun()
 219                 except ImportError:
 220                         try:
 221                                 import Audio_mac
 222                         except ImportError:
 223                                 raise error, 'no audio device'
 224                         else:
 225                                 return Audio_mac.Play_Audio_mac()
 226         else:
 227                 return Play_Audio_sgi()
 228
 229 def test(fn = None):
 230         import sys
 231         if sys.argv[1:]:
 232                 fn = sys.argv[1]
 233         else:
 234                 fn = 'f:just samples:just.aif'
 235         import aifc
 236         af = aifc.open(fn, 'r')
 237         print fn, af.getparams()
 238         p = AudioDev()
 239         p.setoutrate(af.getframerate())
 240         p.setsampwidth(af.getsampwidth())
 241         p.setnchannels(af.getnchannels())
 242         BUFSIZ = af.getframerate()/af.getsampwidth()/af.getnchannels()
 243         while 1:
 244                 data = af.readframes(BUFSIZ)
 245                 if not data: break
 246                 print len(data)
 247                 p.writeframes(data)
 248         p.wait()
 249
 250 if __name__ == '__main__':
 251         test()