def record(self, audio_name: str, max_time: int): input(f"press any key to begin to record {max_time} seconds voice >> ") stream = PyAudio().open(format=paInt16, channels=self.CHANNEL_NUM, rate=self.SAMPLE_RATE, input=True, frames_per_buffer=self.SAMPLE_NUM) my_buf = [] time_start = time.time() last_second = 0 print(f"time: {last_second} s") while True: duration = time.time() - time_start if duration >= max_time: break if int(duration) != last_second: last_second = int(duration) print(f"time: {last_second} s") string_audio_data = stream.read(self.SAMPLE_NUM) my_buf.append(string_audio_data) stream.close() self._save_wave_file(audio_name, my_buf)
def run(self): try: pa = PyAudio() stream = pa.open(format=paInt16, channels=1, rate=16000, input=True, frames_per_buffer=AudioSrc.RECORD_DATA_LEN) while not self.needStop: string_audio_data = stream.read(AudioSrc.RECORD_DATA_LEN) with self.lock: self.data.append(string_audio_data) self.limitBufLen() # print(len(self.data)) pa.close(stream) except: print("AudioSrc is destroyed")
class Audio: def __init__(self): self.RATE = 44100 self.BPM = 100 self.L1 = (60 / self.BPM * 4) * self.RATE self.L2 = self.L1 / 2 self.L4 = self.L1 / 4 self.L8 = self.L1 / 8 self.stream = None def open(self): self.stream = PyAudio().open(format=paFloat32, channels=1, rate=self.RATE, frames_per_buffer=1024, output=True) def play(self, freq, length): t = float(freq) * np.pi * 2 / self.RATE s = np.sin(np.arange(length) * t) self.stream.write(s.astype(np.float32).tostring()) def close(self): self.stream.close()
def audio_freq(): # Значення крайніх нот у моєму випадку (шестиструнна гітара в строї Ре) note_min = 60 # Нота До 4-ї октави note_max = 71 # Нота Сі 4-ї октави sample_freq = 22050 # Частота кадру в герцах # Від збільшення цих констант залежить швидкість оновлення частоти. frame_size = 2048 # Кількість зразків у кадрі frames_per_fft = 16 # Кількість кадрів для середнього значення ШПФ samples_per_fft = frame_size * frames_per_fft # Кількість зразків на ШПФ freq_step = sample_freq / samples_per_fft # Крок частоти # Отримання мінімального та максимального показника для наших нот в межах ШПФ. def note_to_fftbin(n): return 440 * 2.0 ** ((n - 69) / 12.0) / freq_step imin = max(0, int(numpy.floor(note_to_fftbin(note_min - 1)))) imax = min(samples_per_fft, int(numpy.ceil(note_to_fftbin(note_max + 1)))) # Визначення простору для ШПФ. buf = numpy.zeros(samples_per_fft, dtype=numpy.float32) # Функція вікна Хеннінга. window = 0.5 * (1 - numpy.cos(numpy.linspace(0, 2*numpy.pi, samples_per_fft, False))) # Відкриваємо аудіо потік. stream = PyAudio().open(format=paInt16, channels=1, rate=sample_freq, input=True, frames_per_buffer=frame_size) stream.start_stream() # Отримуємо дані, поки потік відкритий. while stream.is_active(): # Оновлюємо буфер та приймаємо нові дані. buf[:-frame_size] = buf[frame_size:] buf[-frame_size:] = numpy.fromstring(stream.read(frame_size), numpy.int16) # Запускаємо ШПФ в буфері в межах вікна. fft = numpy.fft.rfft(buf * window) # Отримуємо максимально повторювану частоту в діапазоні. freq = (numpy.abs(fft[imin:imax]).argmax() + imin) * freq_step # Запис відображення ноти (get_note) у файл freqs.txt freq_save(get_note(freq)) # Правильно закриваємо аудіо потік. stream.stop_stream() stream.close() stream.terminate()
# sym_q.put((0, 0, 1)) # sym_q.put('2') sym_q.put('0') pa = PyAudio() stream = pa.open(format=paFloat32, channels=1, rate=args.samplerate, output=True, frames_per_buffer=SOUND_FRAME_SIZE, stream_callback=callback) network_proc = Process(target=network_producer, args=(args.samplerate, sym_q, s)) # sound_proc = Process(target=sound_consumer, args=(sound_pipe,args.samplerate, stream)) network_proc.start() # sound_proc.start() while stream.is_active(): # a = input() # a = a.strip() # for x in a: # sym_q.put(int(x)) sleep(0.1) pa.close(stream) network_proc.terminate() s.close() except KeyboardInterrupt: # stream.close() pa.close(stream) network_proc.terminate() s.close()
class Activator: """Awaits for the keyword ``Jarvis`` and triggers ``initiator`` when heard. >>> Activator See Also: - Creates an input audio stream from a microphone, monitors it, and detects the specified wake word. - Once detected, Jarvis triggers the ``listener.listen()`` function with an ``acknowledgement`` sound played. - After processing the phrase, the converted text is sent as response to ``initiator()`` with a ``return`` flag. - The ``should_return`` flag ensures, the user is not disturbed when accidentally woke up by wake work engine. """ def __init__(self, input_device_index: int = None): """Initiates Porcupine object for hot word detection. Args: input_device_index: Index of Input Device to use. See Also: - Instantiates an instance of Porcupine object and monitors audio stream for occurrences of keywords. - A higher sensitivity results in fewer misses at the cost of increasing the false alarm rate. - sensitivity: Tolerance/Sensitivity level. Takes argument or env var ``sensitivity`` or defaults to ``0.5`` References: - `Audio Overflow <https://people.csail.mit.edu/hubert/pyaudio/docs/#pyaudio.Stream.read>`__ handling. """ logger.info(f"Initiating hot-word detector with sensitivity: {env.sensitivity}") keyword_paths = [pvporcupine.KEYWORD_PATHS[x] for x in [pathlib.PurePath(__file__).stem]] self.input_device_index = input_device_index self.recorded_frames = [] self.py_audio = PyAudio() self.detector = pvporcupine.create( library_path=pvporcupine.LIBRARY_PATH, model_path=pvporcupine.MODEL_PATH, keyword_paths=keyword_paths, sensitivities=[env.sensitivity] ) self.audio_stream = None def open_stream(self) -> NoReturn: """Initializes an audio stream.""" self.audio_stream = self.py_audio.open( rate=self.detector.sample_rate, channels=1, format=paInt16, input=True, frames_per_buffer=self.detector.frame_length, input_device_index=self.input_device_index ) def close_stream(self) -> NoReturn: """Closes audio stream so that other listeners can use microphone.""" self.py_audio.close(stream=self.audio_stream) self.audio_stream = None def start(self) -> NoReturn: """Runs ``audio_stream`` in a forever loop and calls ``initiator`` when the phrase ``Jarvis`` is heard.""" try: while True: sys.stdout.write("\rSentry Mode") if not self.audio_stream: self.open_stream() pcm = struct.unpack_from("h" * self.detector.frame_length, self.audio_stream.read(num_frames=self.detector.frame_length, exception_on_overflow=False)) self.recorded_frames.append(pcm) if self.detector.process(pcm=pcm) >= 0: playsound(sound=indicators.acknowledgement, block=False) self.close_stream() if phrase := listener.listen(timeout=env.timeout, phrase_limit=env.phrase_limit, sound=False): initiator(phrase=phrase, should_return=True) speaker.speak(run=True) if flag := support.check_restart(): logger.info(f"Restart condition is set to {flag[0]} by {flag[1]}") if flag[1] == "OFFLINE": stop_processes() for _handler in logger.handlers: if isinstance(_handler, logging.FileHandler): logger.removeHandler(hdlr=_handler) handler = custom_handler() logger.info(f"Switching to {handler.baseFilename}") logger.addHandler(hdlr=handler) shared.processes = start_processes() else: stop_processes(func_name=flag[1]) shared.processes[flag[1]] = start_processes(flag[1]) if flag := support.check_stop(): logger.info(f"Stopper condition is set to {flag[0]} by {flag[1]}") self.stop() terminator()