def openDev(self): try: from __main__ import app except: app = None if app is not None: device = app.getPref('audio_device') else: device = None if device is not None: log.msg("ossaudiodev opening device %s") dev = ossaudiodev.open(device, 'rw') else: log.msg("ossaudiodev opening default device") dev = ossaudiodev.open('rw') dev.speed(8000) dev.nonblock() ch = dev.channels(1) if ch not in (1, 2): raise ValueError("insane channel count %r"%(ch)) self._channels = ch formats = listFormats(dev) if 'AFMT_S16_LE' in formats: dev.setfmt(ossaudiodev.AFMT_S16_LE) self.dev = dev else: raise ValueError("Couldn't find signed 16 bit PCM, got %s"%( ", ".join(formats))) self.LC = LoopingCall(self._push_up_some_data) self.LC.start(0.010)
def openDev(self): try: from __main__ import app except: app = None if app is not None: device = app.getPref('audio_device') else: device = None if device is not None: log.msg("ossaudiodev opening device %s") dev = ossaudiodev.open(device, 'rw') else: log.msg("ossaudiodev opening default device") dev = ossaudiodev.open('rw') dev.speed(8000) dev.nonblock() ch = dev.channels(1) if ch not in (1, 2): raise ValueError("insane channel count %r" % (ch)) self._channels = ch formats = listFormats(dev) if 'AFMT_S16_LE' in formats: dev.setfmt(ossaudiodev.AFMT_S16_LE) self.dev = dev else: raise ValueError("Couldn't find signed 16 bit PCM, got %s" % (", ".join(formats))) self.LC = LoopingCall(self._push_up_some_data) self.LC.start(0.010)
def available(cls): """returns True if OSS output is available on the system""" try: import ossaudiodev ossaudiodev.open("w").close() return True except (ImportError, IOError): return False
def setupDDV(self, device = "/dev/ttyu0", port = "9600/8/N/1", timeout = 60.): if self.DEBUG_MODE: self.log.info("Running...") # These need to be changed first self.BACKEND = "DDV" self.PROTOCOL_FOOTER = "*DDVF*" self.PROTOCOL_HEADER = "*DDVH*" self.setupRS232(device, port, timeout) # Fudge some settings for improved performance self.DATA_LENGTH = 16384 self.MAX_RETRIES = 1 self.TX_HANGTIME = 0. self.TX_WAIT = 0. # Ensure we can get access to the soundcard, otherwise disable DDV mode self.ddv_enabled = False try: import ossaudiodev if self.DEBUG_MODE: self.log.info("Setting up DSP device \"%s\" for recording..." % self.DDV_DSP_RECORD_DEVICE) self.ddv_dsp_record = ossaudiodev.open(self.DDV_DSP_RECORD_DEVICE, "r") self.ddv_dsp_record.setfmt(ossaudiodev.AFMT_S16_LE) self.ddv_dsp_record.channels(self.DDV_AUDIO_CHANNELS) self.ddv_dsp_record.speed(self.DDV_AUDIO_SAMPLERATE) if self.DEBUG_MODE: self.log.info("Setting up DSP device \"%s\" for playback..." % self.DDV_DSP_PLAY_DEVICE) self.ddv_dsp_play = ossaudiodev.open(self.DDV_DSP_PLAY_DEVICE, "w") self.ddv_dsp_play.setfmt(ossaudiodev.AFMT_S16_LE) self.ddv_dsp_play.channels(self.DDV_AUDIO_CHANNELS) self.ddv_dsp_play.speed(self.DDV_AUDIO_SAMPLERATE) self.ddv_enabled = True self.log.info("OSS module imported and configured successfully.") except Exception, ex: self.ddv_enabled = False self.log.fatal(str(ex)) self.log.info("Unable to import and configure the OSS module, DDV will be disabled.")
def initialize(self, mode): if not self.fake: self.dev = ossaudiodev.open(self.deviceName, mode) self.dev.setparameters(self.format, self.number_of_channels, self.sample_rate) self.status = mode
def play_sound_file(data, rate, ssize, nchannels): try: dsp = ossaudiodev.open('w') except IOError, msg: if msg[0] in (errno.EACCES, errno.ENODEV, errno.EBUSY): raise TestSkipped, msg raise TestFailed, msg
def init(self, sample_rate, channels, channel_mask, bits_per_sample): """initializes the output stream this *must* be called prior to play() and close()""" if (not self.initialized): import ossaudiodev self.sample_rate = sample_rate self.channels = channels self.channel_mask = channel_mask self.bits_per_sample = bits_per_sample self.ossaudio = ossaudiodev.open('w') if (self.bits_per_sample == 8): self.ossaudio.setfmt(ossaudiodev.AFMT_S8_LE) elif (self.bits_per_sample == 16): self.ossaudio.setfmt(ossaudiodev.AFMT_S16_LE) elif (self.bits_per_sample == 24): self.ossaudio.setfmt(ossaudiodev.AFMT_S16_LE) else: raise ValueError("Unsupported bits-per-sample") self.ossaudio.channels(channels) self.ossaudio.speed(sample_rate) self.initialized = True else: self.close() self.init(sample_rate=sample_rate, channels=channels, channel_mask=channel_mask, bits_per_sample=bits_per_sample)
def play_sound_file(data, rate, ssize, nchannels): try: dsp = ossaudiodev.open('w') except IOError, msg: if msg[0] in (errno.EACCES, errno.ENOENT, errno.ENODEV, errno.EBUSY): raise TestSkipped, msg raise TestFailed, msg
def play(filename): logging.info('opening file %s', filename) sound_file = wave.open(filename, 'rb') try: logging.debug('getting parameters') (nc, sw, fr, nf, comptype, compname) = sound_file.getparams() logging.debug('parameters were %s', (nc, sw, fr, nf, comptype, compname)) logging.debug('opening audio') sound = ossaudiodev.open('w') try: logging.debug('setting parameters') sound.setparameters(ossaudiodev.AFMT_S16_NE, nc, fr) logging.debug('read/write loop') data = sound_file.readframes(FRAME_SIZE) while data: sound.write(data) data = sound_file.readframes(FRAME_SIZE) finally: logging.debug('closing sound device') sound.close() finally: logging.debug('closing file') sound_file.close()
def play(filename): """ play a .wav file for Windows, Linux, or Mac for Mac, you need to have the "play" application in the current folder (.) """ if type(filename) != type(''): raise(TypeError, 'filename must be a string') if os.name == 'nt': winsound.PlaySound(filename, winsound.SND_FILENAME) elif os.uname()[0] == 'Linux': (params, frames) = get_data(filename) oss = ossaudiodev.open('w') if wave.big_endian: if params[1] == 1: oss.setfmt(ossaudiodev.AFMT_S8_BE) else: oss.setfmt(ossaudiodev.AFMT_S16_BE) else: if params[1] == 1: oss.setfmt(ossaudiodev.AFMT_S8_LE) else: oss.setfmt(ossaudiodev.AFMT_S16_LE) oss.channels(params[0]) oss.speed(params[2]) oss.writeall(frames) oss.close() # assume MAC, if not a Windows or Linux machine # if you're using another OS, you'll need to adjust this... else: os.system(('./play ' + filename))
def open_audio(self): if self.impl: self.close_audio() self.impl = ossaudiodev.open("/dev/dsp", "w") self.impl.setparameters(ossaudiodev.AFMT_S16_LE, 1, self.sampling_rate) self.impl.nonblock() self.playing = False
def _ossplay(wav): """ Play a sound with OSS, for FreeBSD & OpenBSD """ try: import ossaudiodev except ImportError: logging.info("_ossplay: Unable to load ossaudiodev module") return False (nc, sw, fr, nf, comptype, compname) = wav.getparams() try: dev = ossaudiodev.open('/dev/dsp', 'w') except IOError: logging.info("_ossplay: Unable to open /dev/dsp; `{}'".format( (sys.exc_info()[1]))) return False try: from ossaudiodev import AFMT_S16_NE except ImportError: if byteorder == 'little': AFMT_S16_NE = ossaudiodev.AFMT_S16_LE else: AFMT_S16_NE = ossaudiodev.AFMT_S16_BE try: dev.setparameters(AFMT_S16_NE, nc, fr) data = wav.readframes(nf) s.close() dev.write(data) finally: dev.close()
def play_sound(self, soundfile): import ossaudiodev import sndhdr try: (t, r, c, f, b) = sndhdr.what(soundfile) except Exception as e: print(f"Unable to determine sound header of {soundfile}: {e}") return if t != "wav": print(f"Unable to play non-wav file {soundfile}") return if b != 16: print(f"Unable to support strange non-16-bit audio ({b})") return dev = None try: dev = ossaudiodev.open("w") dev.setfmt(ossaudiodev.AFMT_S16_LE) dev.channels(c) dev.speed(r) f = file(soundfile, "rb") dev.write(f.read()) f.close() dev.close() except Exception as e: print(f"Error playing sound {soundfile}: {e}") if dev: dev.close()
def play(data): """ Play the given audio samples. @param data: audio samples @type data: string of bytes of audio samples """ if not PLAY_ENABLED: print( "sorry, currently we don't support audio playback on this platform:", sys.platform, file=sys.stderr) return try: dsp = ossaudiodev.open('w') except IOError as e: print( "can't acquire the audio device; please activate your audio device.", file=sys.stderr) print("system error message:", str(e), file=sys.stderr) return dsp.setfmt(ossaudiodev.AFMT_S16_LE) dsp.channels(1) dsp.speed(16000) dsp.write(data) dsp.close()
def _playsoundNix(sound, block = True): ''' Utilizes ossaudiodev. Untested. Probably works with all version of Linux with Python 2.3 or newer. Inspired by, and more or less copied from, Bill Dandreta's post on this mailing list (since deleted, so I link to a web archive instead): https://web.archive.org/web/20080218155209/http://mail.python.org/pipermail/python-list/2004-October/288905.html ''' import ossaudiodev from sys import byteorder from wave import open as waveOpen, AFMT_S16_LE, AFMT_S16_BE with waveOpen(sound, 'rb') as sound: channelCount, sampleWidth, framerate, frameCount, compressionType, compressionName = sound.getparams() try: from ossaudiodev import AFMT_S16_NE except ImportError: if 'little' in byteorder.lower(): AFMT_S16_NE = ossaudiodev.AFMT_S16_LE else: AFMT_S16_NE = ossaudiodev.AFMT_S16_BE data = sound.readframes(frameCount) speaker = ossaudiodev.open('/dev/dsp', 'w') speaker.setparameters(AFMT_S16_NE, channelCount, framerate) speaker.write(data) speaker.close()
def __init__(self, fname, time_interval=None, lag=0.): """ Initialize class. """ threading.Thread.__init__(self) if not time_interval: time_interval = 0.05 self.time_interval = time_interval self.lock = threading.Lock() self.is_running = False self._timestamp = None b, e = os.path.splitext(fname) #if not (e == '.mp3' or e == '.m4a'): # fname = b + '.mp3' fname = os.path.normpath(fname) if not os.path.isfile(fname): raise IOError('Input file does not exist: %s' % fname) print('Load audio data: %s' % os.path.basename(fname)) b, e = os.path.splitext(fname) fname_wav = b + '.wav' data_audio, sample_rate = read_wav(fname_wav) num_frames, num_channels = data_audio.shape self.fname = fname self.data_audio = data_audio self.num_frames = num_frames self.num_channels = num_channels self.sample_rate = sample_rate print('Load audio analysis') self.audio_beats, self.audio_segments = analyze_song(fname) print('Configure audio device') self.chunk_size = int(self.time_interval * self.sample_rate) print(' time interval: %.1f ms' % (self.time_interval*1000)) print(' audio chunk size: %d' % self.chunk_size) self.audio_device = ossaudiodev.open('w') self.audio_device.setparameters(ossaudiodev.AFMT_S16_LE, self.num_channels, self.sample_rate) bufsize = self.audio_device.bufsize() self.bufsize = bufsize print(' audio buffer size: %d' % bufsize) time.sleep(0.01) self.audio_device.setparameters(ossaudiodev.AFMT_S16_LE, self.num_channels, self.sample_rate) # Estimate time lag. self.lag = float(bufsize)/self.chunk_size * self.time_interval + lag print(' time lag: %.3f' % self.lag)
def play(filename): logging.info('opening file %s', filename) sound_file = wave.open(filename,'rb') try: logging.debug('getting parameters') (nc, sw, fr, nf, comptype, compname) = sound_file.getparams() logging.debug('parameters were %s', (nc, sw, fr, nf, comptype, compname)) logging.debug('opening audio') sound = ossaudiodev.open('w') try: logging.debug('setting parameters') sound.setparameters(ossaudiodev.AFMT_S16_NE, nc, fr) logging.debug('read/write loop') data = sound_file.readframes(FRAME_SIZE) while data: sound.write(data) data = sound_file.readframes(FRAME_SIZE) finally: logging.debug('closing sound device') sound.close() finally: logging.debug('closing file') sound_file.close()
def get_swipe(dev='/dev/audio'): audio = ossaudiodev.open(dev, 'r') audio.setparameters(ossaudiodev.AFMT_S16_LE, 1, 44100) baselines = deque([2**15] * 4) bias = 0 while 1: data, power = get_chunk(audio, bias) baseline = sum(baselines) / len(baselines) * THRESHOLD_FACTOR print power, baseline, power / (baseline or 1) chunks = [] while power > baseline: print power, baseline, power / (baseline or 1), '*' chunks.append(data) data, power = get_chunk(audio, bias) if len(chunks) > 1: data = old_data + ''.join(chunks) + data while audioop.maxpp(data[:3000], 2) < baseline / 2: data = data[1000:] while audioop.maxpp(data[-3000:], 2) < baseline / 2: data = data[:-1000] return audioop.bias(data, 2, -audioop.avg(data, 2)) old_data = data bias = -audioop.avg(data, 2) baselines.popleft() baselines.append(power)
def sampleaudio(filename, seconds=2.0, devname="/dev/dsp", samplerate=44100, byteorder="little"): dev = audio.open(devname, 'r') try: from ossaudiodev import AFMT_S16_NE except: if byteorder == "big": AFMT_S16_NE = audio.AFMT_S16_BE else: AFMT_S16_NE = audio.AFMT_S16_LE fmt = dev.setfmt(AFMT_S16_NE) channels = dev.channels(1) rate = dev.speed(samplerate) timearray = [] timearray.append(time.time() * 1000.0) bytestring = dev.read(int(seconds*rate*2)) timearray.append(time.time() * 1000.0) timearray.append(rate/1000.0) dev.close() data = np.fromstring(bytestring, dtype=np.int16) np.savetxt(filename, data) return np.array(timearray, dtype=np.float)
def _playsoundNix(sound, block=True): ''' Utilizes ossaudiodev. Untested. Probably works with all version of Linux with Python 2.3 or newer. Inspired by, and more or less copied from, Bill Dandreta's post on this mailing list (since deleted, so I link to a web archive instead): https://web.archive.org/web/20080218155209/http://mail.python.org/pipermail/python-list/2004-October/288905.html ''' import ossaudiodev from sys import byteorder from wave import open as waveOpen, AFMT_S16_LE, AFMT_S16_BE with waveOpen(sound, 'rb') as sound: channelCount, sampleWidth, framerate, frameCount, compressionType, compressionName = sound.getparams( ) try: from ossaudiodev import AFMT_S16_NE except ImportError: if 'little' in byteorder.lower(): AFMT_S16_NE = ossaudiodev.AFMT_S16_LE else: AFMT_S16_NE = ossaudiodev.AFMT_S16_BE data = sound.readframes(frameCount) speaker = ossaudiodev.open('/dev/dsp', 'w') speaker.setparameters(AFMT_S16_NE, channelCount, framerate) speaker.write(data) speaker.close()
def __init__(self): out = ossaudiodev.open('w') out.channels(1) out.setfmt(ossaudiodev.AFMT_S16_LE) out.speed(44100) self.channel = out self._play = out.writeall
def __init__(self, OSSIETalk_ref): '''Initialization. Sets a reference to parent. Initializes the buffer. Starts the Process data thread, which waits for data to be added to the buffer''' self.OSSIETalk_ref = OSSIETalk_ref # new method: self.num_channels = audio_channels self.Fs = audio_sampling_frequency try: self.speaker_driver = ossaudiodev.open('w') except IOError: print "[WorkModules] Failed to open playback device for writing" self.speaker_driver.setfmt(ossaudiodev.AFMT_S16_LE) self.speaker_driver.channels(self.num_channels) self.speaker_driver.speed(self.Fs) self.data_queue = [] self.data_queue_lock = threading.Lock() self.data_signal = threading.Event() self.is_running = True # old method: #self.channels = 2 #self._setup_sound() self.my_decoder = cvsd.decoder() self.process_thread = threading.Thread(target=self.Process) self.process_thread.start()
def test_main(): try: dsp = ossaudiodev.open('w') except (ossaudiodev.error, IOError), msg: if msg[0] in (errno.EACCES, errno.ENOENT, errno.ENODEV, errno.EBUSY): raise TestSkipped(msg) raise
def __init__(self): if sys.platform == 'linux2': import ossaudiodev self.stream = ossaudiodev.open('w') self.stream.setparameters(ossaudiodev.AFMT_S16_LE, 2, 44100) else: self.p = pyaudio.PyAudio() self.stream = self.p.open(format=self.p.get_format_from_width(2), channels=2, rate=44100, output=True)
def play_sound_file(self, data, rate, ssize, nchannels): try: dsp = ossaudiodev.open('w') except IOError, msg: if msg.args[0] in (errno.EACCES, errno.ENOENT, errno.ENODEV, errno.EBUSY): raise TestSkipped(msg) raise
def getdev(): import ossaudiodev dev = ossaudiodev.open('rw') dev.speed(8000) #dev.nonblock() ch = dev.channels(1) dev.setfmt(ossaudiodev.AFMT_S16_LE) return dev
def __init__(self, device, rate): self.ossdevice = ossaudiodev.open(device, "w") if sys.byteorder == 'little': self.ossdevice.setfmt(ossaudiodev.AFMT_S16_LE) else: self.ossdevice.setfmt(ossaudiodev.AFMT_S16_BE) self.ossdevice.channels(2) self.ossdevice.speed(rate)
def __init__(self): self.audio = ossaudiodev.open('rw') self.audio.setfmt(format) self.audio.channels(2) self.speed = self.audio.speed(speed) self.data = '' self.buffer = array.array('B') self.index = 0
def __init__(self, state): self.output = ossaudiodev.open('w') self.Clip = None self.file = None self.state = state state.addObserver(self) self.isPlaying = False self.src = None self.t = None
def playwave(wavefile): fo = wave.open(wavefile, "rb") (nc, sw, fr, nf, comptype, compname) = fo.getparams() dsp = ossaudiodev.open("/dev/dsp", "w") dsp.setparameters(ossaudiodev.AFMT_S16_NE, nc, fr) data = fo.readframes(nf) fo.close() dsp.write(data) dsp.close()
def oss_open(self): import ossaudiodev self.oss = ossaudiodev.open("/dev/dsp" + str(self.card) + ".0", "r") self.oss.setfmt(ossaudiodev.AFMT_S16_LE) self.oss.channels(2) assert self.oss.speed(self.rate) == self.rate self.th = threading.Thread(target=lambda: self.oss_thread()) self.th.daemon = True self.th.start()
def oss_open(self): import ossaudiodev self.oss = ossaudiodev.open("/dev/dsp" + str(self.card) + ".0", "r") self.oss.setfmt(ossaudiodev.AFMT_S16_LE) self.oss.channels(2) assert self.oss.speed(self.rate) == self.rate self.th = threading.Thread(target=lambda : self.oss_thread()) self.th.daemon = True self.th.start()
def play_audio(self, voice, text): reply = self.request("synth", voice, text) if reply["sampletype"] != "int16": raise Exception("Client currently only supports 16bit samplesize") # try using pyaudio try: import pyaudio chunk = 1024 start = 0 end = 1024 p = pyaudio.PyAudio() # note: currently supports only 'int16' sample types (i.e. samplewidth = 2) samplewidth = 2 # open stream stream = p.open( format=p.get_format_from_width(samplewidth), channels=1, rate=reply["samplerate"], output=True ) num_samples = len(reply["samples"]) / 2 while end < num_samples: stream.write(reply["samples"][start:end]) start = end end = end + chunk stream.write(reply["samples"][start:]) stream.stop_stream() stream.close() p.terminate() # no pyaudio except ImportError: import os opsys = os.name if opsys not in ("posix", "nt"): raise EnvironmentError( "TTSClient.play_audio() currently works only on" + ' "posix" and "nt" compatible systems' ) if opsys == "posix": import ossaudiodev dsp = ossaudiodev.open("w") dsp.setparameters(ossaudiodev.AFMT_S16_LE, 1, reply["samplerate"], True) dsp.writeall(reply["samples"]) dsp.close() else: # nt (win) import winsound winsound.PlaySound(reply["samples"], winsound.SND_MEMORY)
def play_audio(self, voice, text): reply = self.request("synth", voice, text) if reply["sampletype"] != "int16": raise Exception("Client currently only supports 16bit samplesize") # try using pyaudio try: import pyaudio chunk = 1024 start = 0 end = 1024 p = pyaudio.PyAudio() # note: currently supports only 'int16' sample types (i.e. samplewidth = 2) samplewidth = 2 # open stream stream = p.open(format=p.get_format_from_width(samplewidth), channels=1, rate=reply["samplerate"], output=True) num_samples = len(reply["samples"]) / 2 while (end < num_samples): stream.write(reply["samples"][start:end]) start = end end = end + chunk stream.write(reply["samples"][start:]) stream.stop_stream() stream.close() p.terminate() #no pyaudio except ImportError: import os opsys = os.name if opsys not in ("posix", "nt"): raise EnvironmentError("TTSClient.play_audio() currently works only on" + \ " \"posix\" and \"nt\" compatible systems") if opsys == "posix": import ossaudiodev dsp = ossaudiodev.open("w") dsp.setparameters(ossaudiodev.AFMT_S16_LE, 1, reply["samplerate"], True) dsp.writeall(reply["samples"]) dsp.close() else: # nt (win) import winsound winsound.PlaySound(reply["samples"], winsound.SND_MEMORY)
def test_main(): try: dsp = ossaudiodev.open('w') except (ossaudiodev.error, IOError) as msg: if msg.args[0] in (errno.EACCES, errno.ENOENT, errno.ENODEV, errno.EBUSY): raise TestSkipped(msg) raise dsp.close() support.run_unittest(__name__)
def get_oss_audio_device(dev="/dev/audio"): """Get the ossaudiodev.""" try: import ossaudiodev audio = ossaudiodev.open(dev, "r") audio.setparameters(ossaudiodev.AFMT_S16_LE, 1, 44100) return audio except Exception: raise DecodeError("Failed to open OSS audio device.")
def test_set_parameters(self): dsp = ossaudiodev.open("w") try: self.set_parameters(dsp) # Disabled because it fails under Linux 2.6 with ALSA's OSS # emulation layer. #self.set_bad_parameters(dsp) finally: dsp.close() self.failUnless(dsp.closed)
def open(self): #Try to open device in read-write mode try: self.device = dev.open('rw') self.device.setparameters(dev.AFMT_S16_LE, CHANNELS, SAMPLE_RATE) self.device.nonblock() self.isopen = True except IOError: print "Couldn't open device..." self.isopen = False return self.isopen
def __init__(self): if sys.platform == 'linux2': # make sure you've started this with $ padsp python infinite_playlist [...] import ossaudiodev self.stream = ossaudiodev.open('w') self.stream.setparameters(ossaudiodev.AFMT_S16_LE, 2, 44100) else: import pyaudio self.p = pyaudio.PyAudio() self.stream = self.p.open(format=self.p.get_format_from_width(2), channels=2, rate=44100, output=True)
def music_delivery(self, session, frames, frame_size, num_frames, sample_type, sample_rate, channels): if num_frames == 0: if self._device is not None: self._device.close() self._device = None return 0 if self._device is None: self._device = ossaudiodev.open('w') self._device.setparameters(self._format, channels, sample_rate) self._device.write(frames) return num_frames
def close(self): # Yeah, we have to make it crossplatform if sys.platform == "win32": import winsound winsound.PlaySound(self.audio, winsound.SND_MEMORY) elif sys.platform.startswith("linux"): def f(n): return ord(n) if isinstance(n, str) else n sample_rate = 0 sample_rate |= f(self.audio[24]) sample_rate |= f(self.audio[25]) << 8 sample_rate |= f(self.audio[26]) << 16 sample_rate |= f(self.audio[27]) << 24 raw = self.audio[44:] try: os.stat("/dev/dsp") # Worked, using OSS import ossaudiodev with ossaudiodev.open("w") as audio: audio.setfmt(ossaudiodev.AFMT_U8) audio.channels(1) audio.speed(sample_rate) audio.write(raw) except IOError: # Didn't work, using PulseAudio import ctypes import struct class Spec(ctypes.Structure): _fields_ = (("format", ctypes.c_int), ("rate", ctypes.c_uint32), ("channels", ctypes.c_uint8)) spec = Spec(0, sample_rate, 1) pa = ctypes.cdll.LoadLibrary("libpulse-simple.so.0") s = pa.pa_simple_new(None, "PDPy11", 1, None, "PDPy11", ctypes.byref(spec), None, None, None) pa.pa_simple_write(s, raw, len(raw), None) pa.pa_simple_drain(s) pa.pa_simple_free(s) elif sys.platform == "darwin": import subprocess import tempfile path = tempfile.mktemp() with open(path, "w") as f: f.write(self.audio) subprocess.Popen(["afplay", "-q", "1", path]).wait() os.unlink(path)
def __init__(self,rate=44100,channels=2,fps=30): try: self.ao=oss.open_audio() except: self.ao=oss.open('w') if (hasattr(self.ao,'stereo')): self.ao.stereo(1) self.ao.speed(rate) if (hasattr(self.ao,'format')): self.ao.format(oss.AFMT_S16_LE) else: self.ao.setfmt(oss.AFMT_S16_LE) self.ao.channels(channels)
def doPlayOss(self): dev = ossaudiodev.open(self.device, "w") fdtuple = self.handle.loadFile() dev.setfmt(ossaudiodev.AFMT_S16_LE) dev.channels(2) dev.speed(fdtuple[0][1]) while self.shouldPlay: buf = fdtuple[1].read() if buf is None or self.shouldNext: break dev.write(buf) dev.close() return self.shouldPlay
def test(): (data, rate, ssize, nchannels) = read_sound_file(findfile('audiotest.au')) play_sound_file(data, rate, ssize, nchannels) dsp = ossaudiodev.open("w") try: test_setparameters(dsp) # Disabled because it fails under Linux 2.6 with ALSA's OSS # emulation layer. #test_bad_setparameters(dsp) finally: dsp.close()
def print_fmts(rw): print(rw == "r" and "read" or "write") sound = ossaudiodev.open(rw) fmts = sound.getfmts() for name in dir(ossaudiodev): if name.startswith("AFMT"): attr = getattr(ossaudiodev, name) if attr & fmts: print(name) print() sound.close()
def print_fmts(rw): print(rw == 'r' and 'read' or 'write') sound = ossaudiodev.open(rw) fmts = sound.getfmts() for name in dir(ossaudiodev): if name.startswith('AFMT'): attr = getattr(ossaudiodev, name) if attr & fmts: print(name) print() sound.close()
def __init__(self, audio_file): self.af = audio_file self.wf = wave.open(self.get_wav(), 'rb') if sys.platform == 'linux2': # make sure you've started this with $ padsp python infinite_playlist [...] import ossaudiodev self.stream = ossaudiodev.open('w') self.stream.setparameters(ossaudiodev.AFMT_S16_LE, self.af.numChannels, self.af.sampleRate) else: import pyaudio p = pyaudio.PyAudio() self.stream = p.open(format=p.get_format_from_width(self.wf.getsampwidth()), channels=self.af.numChannels, rate=self.af.sampleRate, output=True)
def set_format(self, sample_rate, channels, channel_mask, bits_per_sample): """sets the output stream to the given format if the stream hasn't been initialized, this method initializes it if the stream has been initialized to a different format, this method closes and reopens the stream to the new format if the stream has been initialized to the same format, this method does nothing""" if (self.__ossaudio__ is None): # output hasn't been initialized import ossaudiodev AudioOutput.set_format(self, sample_rate, channels, channel_mask, bits_per_sample) # initialize audio output device and setup framelist converter self.__ossaudio__ = ossaudiodev.open('w') self.__ossmixer__ = ossaudiodev.openmixer() if (self.bits_per_sample == 8): self.__ossaudio__.setfmt(ossaudiodev.AFMT_S8_LE) self.__converter__ = lambda f: f.to_bytes(False, True) elif (self.bits_per_sample == 16): self.__ossaudio__.setfmt(ossaudiodev.AFMT_S16_LE) self.__converter__ = lambda f: f.to_bytes(False, True) elif (self.bits_per_sample == 24): from audiotools.pcm import from_list self.__ossaudio__.setfmt(ossaudiodev.AFMT_S16_LE) self.__converter__ = lambda f: from_list([ i >> 8 for i in list(f) ], self.channels, 16, True).to_bytes(False, True) else: raise ValueError("Unsupported bits-per-sample") self.__ossaudio__.channels(channels) self.__ossaudio__.speed(sample_rate) elif (not self.compatible(sample_rate=sample_rate, channels=channels, channel_mask=channel_mask, bits_per_sample=bits_per_sample)): # output has been initialized to a different format self.close() self.set_format(sample_rate=sample_rate, channels=channels, channel_mask=channel_mask, bits_per_sample=bits_per_sample)
def play_sound(sfile, dur=None): """play the first <dur> seconds of the specified wav file""" sf = wave.open(sfile, 'rb') ad = ossaudiodev.open('w') fmt = [ossaudiodev.AFMT_S8, ossaudiodev.AFMT_S16_LE][sf.getsampwidth() - 1] sr = sf.getframerate() ad.setparameters(fmt, sf.getnchannels(), sr) if dur is None: nframes = sf.getnframes() else: nframes = int(dur * sr) ad.write(sf.readframes(nframes)) sf.close() ad.close()
def _PlayFile(self, filename): self._logger.info('Playing %s' % filename) mf = mad.MadFile(filename) dev = ossaudiodev.open('w') dev.speed(mf.samplerate()) dev.setfmt(ossaudiodev.AFMT_S16_LE) dev.channels(2) while True: if self._file_queue.qsize(): break buf = mf.read() if buf is None: break dev.write(buf)