def start(self, send=True, receive=True): """ Start audio I/O stream and processing thread """ if receive: sd.check_input_settings(device=self.input_device, channels=1, dtype=self.sample_size, samplerate=self.sdk.sample_rate) self.processing = AudioProcessingThread(parent=self) self.input_stream = sd.RawInputStream(device=self.input_device, channels=1, samplerate=int( self.sdk.sample_rate), dtype=self.sample_size, blocksize=self.block_size, callback=self.process_input) self.input_stream.start() if send: sd.check_output_settings(device=self.output_device, channels=self.output_channels, dtype=self.sample_size, samplerate=self.sdk.sample_rate) self.output_stream = sd.RawOutputStream( device=self.output_device, channels=self.output_channels, samplerate=int(self.sdk.sample_rate), dtype=self.sample_size, blocksize=self.block_size, callback=self.process_output) self.output_stream.start()
def single_measurement(self, type=None): # little workaround of a problem with using ASIO from multiple threads # https://stackoverflow.com/questions/39858212/python-sounddevice-play-on-threads default_device = sd.query_devices(sd.default.device[0]) default_api = sd.query_hostapis(default_device['hostapi']) if default_api['name'] == 'ASIO': sd._terminate() sd._initialize() self.recorded_sweep_l = [] self.recorded_sweep_r = [] self.feedback_loop = [] if type is 'hpc': excitation = self.excitation_hpc else: excitation = self.excitation if not self.dummy_debugging: time.sleep(0.3) try: sd.check_input_settings(channels=self.num_input_channels_used) sd.check_output_settings(channels=self.num_output_channels_used) except: print( "Audio hardware error! Too many channels or unsupported samplerate" ) return # do measurement recorded = sd.playrec(excitation, channels=self.num_input_channels_used) sd.wait() # get the recorded signals if self.channel_layout_input[0] >= 0: self.recorded_sweep_l = recorded[:, self.channel_layout_input[0]] else: self.recorded_sweep_l = np.zeros(np.size(recorded, 0)) if self.channel_layout_input[1] >= 0: self.recorded_sweep_r = recorded[:, self.channel_layout_input[1]] else: self.recorded_sweep_r = np.zeros(np.size(recorded, 0)) if self.feedback_loop_used: self.feedback_loop = recorded[:, self.channel_layout_input[2]] if abs(self.feedback_loop.max()) < 0.0001: self.feedback_loop = np.random.random_sample( self.feedback_loop.shape ) * 0.000001 # to avoid zero-division errors else: # if no FB loop, copy from original excitation sweep if type is 'hpc': self.feedback_loop = self.sweep_hpc_mono[:, 0] else: self.feedback_loop = self.sweep_mono[:, 0]
def is_output_format_supported(self, device, output_format): # raise sounddevice.PortAudioError if the format is not supported # the exception message contains the details, such as an invalid sample rate sounddevice.check_output_settings( device=device['index'], channels=device['max_output_channels'], dtype=output_format, samplerate=SAMPLING_RATE)
def __init__(self): try: sd.check_output_settings('wm8960') except ValueError: raise AIModuleFaultsException( "AI Speaker not found! Please contact our CS team.") for idx, device in enumerate(sd.query_devices()): if 'wm8960' in device: sd.default.device = idx break
def is_output_format_supported(self, device, output_format): try: sounddevice.check_output_settings( device=device['index'], channels=device['max_output_channels'], dtype=output_format, samplerate=SAMPLING_RATE) success = True except Exception as exception: Logger().push("Format is not supported: " + str(exception)) success = False return success
def check_supported_sample_rate(self): import sounddevice as sd samplerates = 16000, 32000, 44100, 48000, 96000 supported_samplerates = [] for fs in samplerates: try: sd.check_output_settings(device=default.input_device_index, samplerate=fs) except Exception as e: #print(fs, e) pass else: supported_samplerates.append(fs) #print(supported_samplerates) return supported_samplerates
def is_output_format_supported(self, device, output_format): try: sounddevice.check_output_settings( device=device['index'], channels=device['max_output_channels'], dtype=output_format, samplerate=SAMPLING_RATE) success = True except Exception as exception: self.logger.push("Format is not supported: " + str(exception)) success = False return success
def test_soundcard(i="default",o="default", fs=fs, ch=2): dummy1sec = zeros(int(fs)) print( 'Trying:' ) print(f' {sd.query_devices(i, kind="input" )["name"]}') print(f' {sd.query_devices(o, kind="output")["name"]}') try: sd.default.device = i, o except Exception as e: print( f'(!) Error accesing devices [{i},{o}]: {e}' ) return e try: chk_rec = sd.check_input_settings (i, channels=ch, samplerate=float(fs)) chk_pb = sd.check_output_settings(o, channels=ch, samplerate=float(fs)) print( f'Sound card parameters OK' ) except Exception as e: print( f'(!) Sound card [{i},{o}] ERROR: {e}' ) return e try: dummy = sd.playrec(dummy1sec, samplerate=fs, channels=ch) print( 'Sound device settings are supported' ) except Exception as e: print( f'(!) FAILED to playback and recording on selected device: {e}' ) return e return 'ok'
def setup_audio_devices(self, sample_rate): input_devices = [] output_devices = [] for device in sd.query_devices(): # Check if valid input try: sd.check_input_settings(device=device["name"], samplerate=sample_rate) input_devices.append(device["name"]) except: pass # Check if valid output try: sd.check_output_settings(device=device["name"], samplerate=sample_rate) output_devices.append(device["name"]) except Exception as e: # Log a warning only if the device is not an input if not device["name"] in input_devices: warn( "Unsupported output device %s for the sample rate: %d \nError: %s" % (device["name"], sample_rate, str(e))) if len(input_devices) == 0: self.log("No audio input device detected. Recording may not work.") self.audio_in_devices_cb.addItems(["None"]) self.audio_in_devices_cb.setDisabled(True) else: self.audio_in_devices_cb.clear() self.audio_in_devices_cb.addItems(input_devices) self.audio_in_devices_cb.currentTextChanged.connect( self.set_audio_device) if len(output_devices) == 0: self.log( "No supported output audio devices were found! Audio output may not work." ) self.audio_out_devices_cb.addItems(["None"]) self.audio_out_devices_cb.setDisabled(True) else: self.audio_out_devices_cb.clear() self.audio_out_devices_cb.addItems(output_devices) self.audio_out_devices_cb.currentTextChanged.connect( self.set_audio_device) self.set_audio_device()
def get_audio_output_device_supported_sample_rates(device, channels, dtype, verbose=False): supported_samplerates = [] for fs in (32000, 44100, 48000, 96000, 128000): try: sd.check_output_settings(device=device, samplerate=fs, channels=channels, dtype=dtype) except Exception as e: if verbose: print(fs, e) else: supported_samplerates.append(fs) return supported_samplerates
def get_device(name='CABLE Input', kind='output', api=0): if isinstance(name, int): return name, sd.query_devices(name) devices = sd.query_devices() matching_devices = [] for device_id in range(len(devices)): if name.lower() in devices[device_id].get('name').lower(): try: if kind == 'input': sd.check_input_settings(device_id) elif kind == 'output': sd.check_output_settings(device_id) else: print('Invalid kind') return None matching_devices.append((device_id, devices[device_id])) except: pass if not matching_devices: print("Unable to find device matching name", name, 'of kind', kind) return None found = False if isinstance(api, int): api = sd.query_hostapis(api).get('name') for device_id, device in matching_devices: if api in sd.query_hostapis(int( device.get('hostapi'))).get('name'): found = True break if not found: print("Unable to find device matching host api", api, 'using first available...') return matching_devices[0] else: return device_id, device
def __init__(self, args): def audio_callback(indata, outdata, frames, time, status): '''Called by audio stream for each new buffer.''' indataQ.append(indata[::, LEFT]) if self.out_enable: outdata[:, LEFT] = self.out_sig else: outdata.fill(0) self.cumulated_status |= status return None self.args = args self.out_enable = False sd.default.device = [args.input_dev, args.output_dev] sd.default.channels = 2 sd.default.dtype = None sd.default.latency = None sd.default.samplerate = args.sample_rate sd.default.blocksize = args.buff_size sd.default.clip_off = True sd.default.dither_off = args.dither sd.default.never_drop_input = None sd.default.prime_output_buffers_using_stream_callback = None # Checks will throw errors for invalid settings. sd.check_input_settings() sd.check_output_settings() # Will store sounddevice status flags on buffer under/overflows, etc. self.cumulated_status = sd.CallbackFlags() # Will store data to write to output buffer. self.out_sig = None # Create the stream self.audio_stream = sd.Stream(callback=audio_callback)
def set_output_device(self, index): """Attempts to set the audio output device. Parameters ---------- index : int The application's index of the output device Notes ----- Emits the `output_device_changed_signal` with the index of the current audio output device. """ if index != self.get_current_output_device_index(): device = self._output_devices[index] try: sound.check_output_settings(device=device['name']) sound.default.device[1] = device['name'] except ValueError: self._logger.push("Output device not supported") print(self.get_current_output_device_index()) self.output_device_changed_success_signal.emit(self.get_current_output_device_index())
def driver_setter(): if ms_win is not None: ms_win.destroy() if list_bx.curselection() == (): message_win( 'Oi!', '''Select a device \n from the list or cancel ''') return num = list_bx.curselection()[0] num_name = sd.query_devices()[num].get('name') try: check_driver = sd.check_output_settings( device=num, channels=2, dtype='float32', samplerate=sample_rate) device_num.set(num) stream_restart(new_blocksize[0]) message_win( 'Driver Set', '''Device number {} ({}) \n set as output device.\n Blocksize = {} '''.format(num, num_name, new_blocksize)) except sd.PortAudioError: message_win('sd.PortAudioError', 'Device number {} ({}) \n is not supported. Try another'.format(num, num_name))
import sounddevice as sd samplerates = 32000, 44100, 48000, 96000, 128000 device = 0 supported_samplerates = [] for fs in samplerates: try: sd.check_output_settings(device=device, samplerate=fs) except Exception as e: print(fs, e) else: supported_samplerates.append(fs) print(supported_samplerates)
parser.add_argument('-u', '--utc', action='store_true', help='set time in UTC') args = parser.parse_args(remaining) print('=' * 80) print('') print( ' DFC77-sync - a tool to synchronize DFC77 devices using sound speakers') print('') print(' For command line options use: dfc77-sync.py -h') print('') print(' Press Return to quit') print('') print('=' * 80) try: sd.check_output_settings(args.device, samplerate=args.samplerate) samplerate = args.samplerate except Exception: samplerate = sd.query_devices(args.device, 'output')['default_samplerate'] try: def callback(outdata, frames, time, status): if status: print(status, file=sys.stderr) global count_sec, count_dec, time_bits if count_sec < 59: if count_dec >= 2: outdata[:] = carrier[:]
import _parseargs as parse import utils as utils # --- Parse command line arguments and check defaults flag_defaultsInitialized = parse._checkdefaults() args = parse._parse() parse._defaults(args) # ------------------------------- if flag_defaultsInitialized == True: if args.listdev == True: print(sd.query_devices()) sd.check_input_settings() sd.check_output_settings() print("Default input and output device: ", sd.default.device) elif args.defaults == True: aa = np.load('_data/defaults.npy', allow_pickle=True).item() for i in aa: print(i + " => " + str(aa[i])) elif args.setdev == True: sd.default.device[0] = args.inputdevice sd.default.device[1] = args.outputdevice sd.check_input_settings() sd.check_output_settings() print(sd.query_devices()) print("Default input and output device: ", sd.default.device)