def __init__(
self,
device=None, # sounddevice to use, set to `None` to use default
fs=44100, # sampling rate, Hz, must be integer
mapping=(1, 2), # mapping of the channels
duration=1.0, # in seconds, may be float
blocksize=1024, # number of frames per channel
**kwargs):
super(BeamCtrl, self).__init__()
hostapi = kwargs.get("hostapi", -1)
if hostapi >= 0:
device = get_device_id(device, hostapi)
sd.default.device = device
self.device = sd.default.device[1]
sd.default.latency = self.latency = 'low'
# sd.default.latency = 0.1
self.device_info = sd.query_devices(self.device)
if self.device_info['hostapi'] == 2:
self.extra_settings = sd.AsioSettings(channel_selectors=mapping)
sd.default.extra_settings = self.extra_settings
mapping = list(range(1, len(mapping) + 1))
elif self.device_info['hostapi'] == 3:
exclusive = kwargs.get("exclusive", False)
self.extra_settings = sd.WasapiSettings(exclusive=exclusive)
sd.default.extra_settings = self.extra_settings
else:
self.extra_settings = None
pprint(self.device_info)
self.fs = self.device_info['default_samplerate']
self.duration = duration
self.n_channels = len(mapping)
self.mapping = mapping
self.dtype = np.float32
self.blocksize = int(ceil(fs * duration))
self.signal_data = np.empty((self.blocksize, self.n_channels),
dtype=self.dtype)
self.channel_data = None
def __init__(self):
"""Get init values"""
logger.debug("Initiating Visualizer")
self.p = pyaudio.PyAudio()
dev_info = self.p.get_device_info_by_index(0)
self.rate = int(dev_info["defaultSampleRate"])
self.format = pyaudio.paInt16
self.chunksize = int(1024 * self.multi)
self.deviceIndex = dev_info["index"]
self.channels = 2
print_available_devices()
self.defaultDevice = self.p.get_default_input_device_info()["index"]
sd.default.device = self.defaultDevice
sd.WasapiSettings(exclusive=True)
# Open WASAPI stream
if self.open_stream() != 0:
logger.critical("Couldn't open Stream! Quitting application..")
exit(1)
self.stream.start()
def __call__(self,
deviceid: list = _sd.default.device,
dtype: _np.dtype or str = 'float32',
**kwargs):
from platform import system
if system() == 'Windows':
kwargs['extra_settings'] = _sd.WasapiSettings(True)
with _sd.OutputStream(self.samplerate,
self.blocksize,
deviceid,
self.nchannels,
dtype,
latency='low',
callback=self.callback,
finished_callback=self.callback_end,
**kwargs) as stream:
with _kb.Listener(on_press=self.key_press,
on_release=self.key_release,
supress=True) as keys:
print(self.welcome())
while stream.active:
_sd.sleep(self.msPF)
if self.stopStream.is_set():
break
print(self.loop_string(len(self.playingNotes),
stream.cpu_load),
end='\r')
keys.join()
self.finished.wait()
print()
print("Goodbye!")
return 0
def _init_mixer(fs, n_channels, api, name, api_options=None):
devices = sounddevice.query_devices()
if len(devices) == 0:
raise OSError('No sound devices found!')
apis = sounddevice.query_hostapis()
for ai, this_api in enumerate(apis):
if this_api['name'] == api:
api = this_api
break
else:
raise RuntimeError('Could not find host API %s' % (api, ))
del this_api
# Name
if name is None:
name = get_config('SOUND_CARD_NAME', None)
if name is None:
global _DEFAULT_NAME
if _DEFAULT_NAME is None:
di = api['default_output_device']
_DEFAULT_NAME = devices[di]['name']
logger.exp('Selected default sound device: %r' % (_DEFAULT_NAME, ))
name = _DEFAULT_NAME
possible = list()
for di, device in enumerate(devices):
if device['hostapi'] == ai:
possible.append(device['name'])
if name in device['name']:
break
else:
raise RuntimeError('Could not find device on API %r with name '
'containing %r, found:\n%s' %
(api['name'], name, '\n'.join(possible)))
param_str = ('sound card %r (devices[%d]) via %r' %
(device['name'], di, api['name']))
extra_settings = None
if api_options is not None:
if api['name'] == 'Windows WASAPI':
# exclusive mode is needed for zero jitter on Windows in testing
extra_settings = sounddevice.WasapiSettings(**api_options)
else:
raise ValueError(
'api_options only supported for "Windows WASAPI" backend, '
'using %s backend got api_options=%s' %
(api['name'], api_options))
param_str += ' with options %s' % (api_options, )
param_str += ', %d channels' % (n_channels, )
if fs is not None:
param_str += ' @ %d Hz' % (fs, )
try:
mixer = Mixer(samplerate=fs,
latency='low',
channels=n_channels,
dither_off=True,
device=di,
extra_settings=extra_settings)
except Exception as exp:
raise RuntimeError('Could not set up %s:\n%s' % (param_str, exp))
assert mixer.channels == n_channels
if fs is None:
param_str += ' @ %d Hz' % (mixer.samplerate, )
else:
assert mixer.samplerate == fs
mixer.start()
assert mixer.active
logger.info('Expyfun: using %s, %0.1f ms nominal latency' %
(param_str, 1000 * device['default_low_output_latency']))
atexit.register(lambda: (mixer.abort(), mixer.close()))
return mixer