Пример #1
0
    def __init__(self, byte_data, sample_rate, bit_width, channels, dtype = None):
        """
        byte_data: A byte string containing the raw data.
        BIT_WIDTH: bit width in bytes.
        """
        
        assert isinstance(bit_width, (int, long)) and bit_width > 0, \
                "`bit_width` must be positive integer."
        bit_width = pyaudio.get_sample_size(pyaudio.get_format_from_width(bit_width))
        
        assert isinstance(channels, int) and channels in [1, 2], \
                "`channels` can be either 1(mono) or 2(stereo)."
        assert channels in (1, 2), \
                "`channels` can be either 1(mono) or 2(stereo) only."
        
        assert sample_rate > 0, "`sample_rate` must be positive."

        self.__bit_width = bit_width
        self.__channels = channels
        self.__sample_rate = sample_rate
        self.__byte_data = byte_data # a byte string

        if dtype is None:
            dtype = self._get_dtype_by_bit_width()

        if not self._validate_dtype(dtype):
            raise ValueError("`dtype` is not compatible with the `bit_width`.")

        self.__dtype = dtype
        self.format = pyaudio.get_format_from_width(self.BIT_WIDTH)
Пример #2
0
def init_pyaudio_stream(PyAudio=PA,
                        width=WIDTH,
                        channels=CHANNELS,
                        rate=RATE,
                        frames_per_buffer=CHUNK,
                        input=False,
                        output=True,
                        blocking=AUDIO_BLOCKING):
    if blocking:
        return PyAudio.open(format=pyaudio.get_format_from_width(width),
                            channels=channels,
                            rate=rate,
                            frames_per_buffer=frames_per_buffer,
                            input=input,
                            output_device_index=0,
                            output=output)
    else:
        return PyAudio.open(format=pyaudio.get_format_from_width(width),
                            channels=channels,
                            rate=rate,
                            frames_per_buffer=frames_per_buffer,
                            input=input,
                            output_device_index=0,
                            output=output,
                            stream_callback=audify_data_callback)
Пример #3
0
def calibrate():
    print ('Calibrating Microphones ...')
    # Play
    stream_1 = calib_play.open(format = pa.get_format_from_width(sweep.getsampwidth()), 
                               channels = channel_count, 
                               rate = sweep.getframerate(), 
                               input = False, output = True, 
                               input_device_index = get_Mics()[0], 
                               output_device_index = get_Spkrs()[0])
    # Record
    stream_2 = calib_recd.open(format = pa.get_format_from_width(sweep.getsampwidth()), 
                               channels = channel_count, 
                               rate = sweep.getframerate(), 
                               input = True, output = False, 
                               input_device_index = get_Mics()[1], 
                               output_device_index = get_Spkrs()[0], 
                               frames_per_buffer = samples_chunk)
    
    frames = []
    in_rms = []
    out_data = sweep.readframes(int(sweep.getframerate()/10))
    for i in range(0, int(sweep.getframerate() / (samples_chunk * 5))):
        stream_1.write(out_data)
        out_data = sweep.readframes(int(sweep.getframerate()/10))
        in_data = stream_2.read(samples_chunk)
        frames.append(in_data)
        rms = np.fromstring(in_data, dtype=np.int16)
        rms = np.sqrt(np.mean(rms ** 2.0))
        in_rms.append(rms)
    global sweep_in_rms
    sweep_in_rms = np.mean(np.array(in_rms)) / 100.0

    stream_1.stop_stream()
    stream_2.stop_stream()
    stream_1.close()
    stream_2.close()
    sweep.close()
    calib_play.terminate()
    calib_recd.terminate()
    
    global sweep_file_rms
    #sweep_file_rms = sweep_file_rms/50.0
    #sweep_in_rms = sweep_in_rms/50.0
    
    print('Sine Sweep RMS from File = ' + str(sweep_file_rms))
    print('Sine Sweep RMS from Mics = ' + str(sweep_in_rms))
    if sweep_file_rms > sweep_in_rms:
        gain_ratio = sweep_in_rms/sweep_file_rms
    else:
        gain_ratio = sweep_file_rms/sweep_in_rms
    
    print ('Gain = ' + str(gain_ratio))
    print ('Microphones Calibrated !')
    time.sleep(5)
    return gain_ratio
Пример #4
0
    def __init__(self, device_index, sample_rate, bit_width, chunk_size = 8092, channels = 1):

        audio = pyaudio.PyAudio()
        ## Checking the device_index is valid or not.
        assert isinstance(device_index, (int, long)), "Device index must be an integer."
        device_count = audio.get_device_count()
        assert 0 <= device_index < device_count, "`device_index` out of range: {} out of {}".format(device_index, count)
        audio.terminate()
        self.__device_index = device_index

        if not self.device_info["maxInputChannels"] > 0:
            raise DeviceTypeError("Can not source from a non-input device.")

        self.__format = pyaudio.get_format_from_width(bit_width)
        self.__bit_width = pyaudio.get_sample_size(self.FORMAT)

        assert isinstance(sample_rate, (int, long)), "`sample_rate` must be integer."
        
        max_sample_rate = self.device_info["defaultSampleRate"]
        assert 0 < sample_rate <= max_sample_rate, "`sample_rate` out of range: {} out of {}".format(sample_rate, max_sample_rate)
        self.__sample_rate = sample_rate

        assert isinstance(chunk_size, (int, long)), "`chunk_size` must be integer."
        self.__chunk_size = chunk_size

        assert channels in [1, 2], '`channels` can be either 1 or 2. 1 for mono audio, 2 for stereo.' 
        self.__channels = channels

        # audio resource and streams.
        self.__audio = None
        self.__input_stream = None
Пример #5
0
 def openStream(self, file, p):
     return p.open(format=pyaudio.get_format_from_width(
         file.getsampwidth()),
                   channels=file.getnchannels(),
                   rate=file.getframerate(),
                   output=True,
                   output_device_index=4)
    def __init__(self, audioformat, queue=None):
        """Constructor.
		Creates a pyaudio sound renderer.
		
		Parameters
		----------
		audioformat : dict
			A dictionary containing the properties of the audiostream
		queue : Queue.queue
			A queue object which serves as a buffer on which the individual
			audio frames are placed by the decoder.
		"""

        global pyaudio
        import pyaudio

        if not queue is None:
            self.queue = queue

        self.pa = pyaudio.PyAudio()
        self.stream = self.pa.open(channels=audioformat["nchannels"],
                                   rate=audioformat["fps"],
                                   frames_per_buffer=audioformat['buffersize'],
                                   format=pyaudio.get_format_from_width(
                                       audioformat["nbytes"]),
                                   output=True,
                                   stream_callback=self.get_frame)
        self.keep_listening = True
Пример #7
0
    def on_command(self, data):
        """
        Perform actions after voice input was recorded.
        :param np.array data: The voice input data
        """
        self.recording_state = False

        # Simulate action
        time.sleep(5)

        if self.raspi_mode:
            self.light.processing()

        # TODO: For now, save the file
        filename = 'testapp' + datetime.now().strftime(
            '%Y-%m-%d_%H-%M-%S') + '.wav'
        wf = wave.open(filename, 'wb')
        wf.setnchannels(self.channels)
        wf.setsampwidth(
            pyaudio.get_sample_size(pyaudio.get_format_from_width(self.width)))
        wf.setframerate(self.sample_rate)
        wf.writeframes(b''.join(data))
        wf.close()

        self.recording = []
        self.data = np.zeros(self.feed_samples, dtype=self.format)
        self.queue.empty()
        self.recording_state = False

        if self.raspi_mode:
            self.light.off()
Пример #8
0
    def playWave(self):
        #define stream chunk
        chunk = 1024
        
        #open wav file
        wFile = wave.open('C:\Users\Liz\workspace\SineLanguage\message.wav', 'rb')
        
        #instantiate pyaudio
        p = pyaudio.PyAudio()

        #open stream
        stream = p.open(format = pyaudio.get_format_from_width(wFile.getsampwidth()), channels = wFile.getnchannels(), rate = wFile.getframerate(), output = True)
        
        #read data
        data = wFile.readframes(chunk)
        
        #play stream
        while data != '':
            stream.write(data)
            data = wFile.readframes(chunk)
        
        #stop stream
        stream.stop_stream()
        stream.close()
        
        #close PyAudio
        p.terminate()
        wFile.close()
Пример #9
0
 def __configure_input_file(self, **kwargs):
     in_file = kwargs[KEY_INPUT_FILE_NAME]
     self.file_source = wave.open(in_file, 'rb')
     self.format = pyaudio.get_format_from_width(
         self.file_source.getsampwidth())
     self.channels = self.file_source.getnchannels()
     self.rate = self.file_source.getframerate()
Пример #10
0
    def create_ui(self):
        self.setWindowTitle('AVCapture')
        self.resize(960, 540)

        self.m_pyaudio = pyaudio.PyAudio()
        self.m_pyaudio_stream = self.m_pyaudio.open(
            format=pyaudio.get_format_from_width(2),
            channels=2,
            rate=48000,
            output=True)
        self.m_pyaudio_stream.start_stream()

        # self.m_video_render = CRenderWid(self)
        self.m_video_render = QRenderWidget(self)
        self.m_video_render.move(0, 0)
        self.m_video_render.resize(self.width(), self.height())

        self.m_menubar = self.menuBar()

        self.m_menu_file = QMenu('File', self.m_menubar)
        self.m_menu_start_act = QAction("Start Record", self)
        self.m_menu_file.addAction(self.m_menu_start_act)
        self.m_menu_start_act.setEnabled(True)
        self.m_menu_stop_act = QAction("Stop Record", self)
        self.m_menu_file.addAction(self.m_menu_stop_act)
        self.m_menu_stop_act.setEnabled(False)
        self.m_menu_save_act = QAction("Save Image", self)
        self.m_menu_file.addAction(self.m_menu_save_act)
        self.m_menu_save_act.setEnabled(True)
        self.m_menu_save_act.triggered.connect(self.slot_button_save)
        self.m_menubar.addMenu(self.m_menu_file)
        self.m_menu_file.triggered.connect(self.slot_file_selected)

        self.m_menu_device = QMenu('Device', self.m_menubar)
        self.m_menu_device_act = []
        device_name_list = self.m_capture.list_device()
        index = 0
        for device_name in device_name_list:
            if device_name.find("Pro Capture") < 0 and device_name.find(
                    "Eco Capture") < 0:
                continue

            action = QAction(device_name, self)
            self.m_menu_device_act.append(action)
            self.m_menu_device.addAction(action)
            action.setCheckable(True)

        self.m_menubar.addMenu(self.m_menu_device)
        self.m_menu_device.triggered.connect(self.slot_device_selected)

        ctrlWidget = MWControlWidget(self.m_capture)
        vbox = QtWidgets.QVBoxLayout()
        vbox.addWidget(self.m_video_render)
        vbox.addWidget(ctrlWidget)
        qpb_save = QPushButton("Save Image")
        qpb_save.clicked.connect(self.slot_button_save)
        vbox.addWidget(qpb_save)
        widget = QtWidgets.QWidget()
        widget.setLayout(vbox)
        self.setCentralWidget(widget)
Пример #11
0
    def _record(self):
        # Start recording audio on the current thread until stop() is
        # called.
        p = pyaudio.PyAudio()
        channels, rate = self.config.CHANNELS, self.config.RATE
        frames_per_buffer = self.config.FRAMES_PER_BUFFER
        pa_format = pyaudio.get_format_from_width(self.config.SAMPLE_WIDTH)
        stream = p.open(input=True, format=pa_format, channels=channels,
                        rate=rate, frames_per_buffer=frames_per_buffer)

        # Start recognising in a loop
        stream.start_stream()
        while self._recording:
            with self._condition:
                self._buffers.append(stream.read(frames_per_buffer))

                # Notify waiting threads (if any).
                self._condition.notifyAll()

            # This improves the performance; we don't need to process as
            # much audio as the device can read.
            time.sleep(self.read_interval)

        stream.close()
        p.terminate()
Пример #12
0
    def run(self):
        self._running = True
        self._stream = self._audio.open(
            format=pyaudio.get_format_from_width(self.params.nbytes),
            channels=self.params.channels,
            rate=self.params.sample_rate,
            input=True,
            frames_per_buffer=self.params.frame_per_buffer)
        while self._stream.is_active() and self._running:
            if self._paused:
                self._stream.stop_stream()
                with self._condition:
                    self._condition.wait()
                    self._stream.start_stream()
            data = self._stream.read(self._chunk_size,
                                     exception_on_overflow=False)
            if self._consumer is not None:
                self._consumer.input(data)

        if self._stream.is_active():
            self._stream.stop_stream()
        if self._running:
            self.on_error("Stream has unexpectedly stopped")
        self._stream.close()
        self._audio.terminate()
Пример #13
0
    def _record(self):
        # Start recording audio on the current thread until stop() is
        # called.
        p = pyaudio.PyAudio()
        channels, rate = self.config.CHANNELS, self.config.RATE
        frames_per_buffer = self.config.FRAMES_PER_BUFFER
        pa_format = pyaudio.get_format_from_width(self.config.SAMPLE_WIDTH)
        stream = p.open(input=True, format=pa_format, channels=channels,
                        rate=rate, frames_per_buffer=frames_per_buffer)

        # Start recognising in a loop
        stream.start_stream()
        while self._recording:
            with self._condition:
                self._buffers.append(stream.read(frames_per_buffer))

                # Notify waiting threads (if any).
                self._condition.notifyAll()

            # This improves the performance; we don't need to process as
            # much audio as the device can read.
            time.sleep(self.read_interval)

        stream.close()
        p.terminate()
Пример #14
0
def play_audio(file_name):

    # sets up file and PyAudio
    file = wave.open(file_name, "rb")
    py_audio = pyaudio.PyAudio()

    # opens the audio stream
    stream = py_audio.open(format=pyaudio.get_format_from_width(
        file.getsampwidth()),
                           channels=file.getnchannels(),
                           rate=file.getframerate(),
                           output=True)

    # read in bytes from file
    data = file.readframes(1024)

    # plays the audio stream
    while data:
        stream.write(data)
        data = file.readframes(1024)

    # closes the stream and terminates
    stream.stop_stream()
    stream.close()
    py_audio.terminate()
Пример #15
0
	def __init__(self, audioformat, queue=None):
		"""Constructor.
		Creates a pyaudio sound renderer.
		
		Parameters
		----------
		audioformat : dict
			A dictionary containing the properties of the audiostream
		queue : Queue.queue
			A queue object which serves as a buffer on which the individual
			audio frames are placed by the decoder.
		"""
		if pyaudio is None:
			raise RuntimeError("Pyaudio sound renderer is not available")

		super(SoundrendererPyAudio, self).__init__()

		if not queue is None:
			self.queue = queue

		self.pa = pyaudio.PyAudio()
		self.stream = self.pa.open(
			channels  	= audioformat["nchannels"],
			rate 		= audioformat["fps"],
			# frames_per_buffer = audioformat['buffersize'],
			format 	= pyaudio.get_format_from_width(audioformat["nbytes"]),
			output 	= True,
		)
Пример #16
0
    def generate_speech(self):
        self.wf.rewind()
        self.input_stream = self.pa.open(format=pyaudio.get_format_from_width(self.wf.getsampwidth()),
                                    channels=1, rate = self.template_rate, input=True,
                                    stream_callback = self.read_callback)
        if (self.muck_up):
            self.wf.close()
            self.wf = wave.open('/home/justin/auditory-soa/sample-completely-different.wav', 'rb')


        self.output_stream = self.pa.open(format=pyaudio.get_format_from_width(self.wf.getsampwidth()),
                                channels=1, rate = self.template_rate,
                                output=True, stream_callback =
                                self.write_callback)
            
        self.template_idx = 0
        self.signal = []
Пример #17
0
    def from_file(cls, original_file):
        """Initialise recording from file"""
        data_sequence, sample_width, num_channels, frame_rate = read_wav(
            original_file)

        return cls(frames=data_sequence,
                   rate=frame_rate,
                   num_channels=num_channels,
                   audio_format=pyaudio.get_format_from_width(sample_width))
Пример #18
0
    def __init__(self, audioformat):
        fps = audioformat["fps"]
        nchannels = audioformat["nchannels"]
        nbytes = audioformat["nbytes"]

        p = pyaudio.PyAudio()
        self.stream = p.open(channels=nchannels,
                             rate=fps,
                             format=pyaudio.get_format_from_width(nbytes),
                             output=True)
Пример #19
0
 def play(self):
     """plays audio"""
     audio = self.get_audio()
     pyaudio_format = pyaudio.get_format_from_width(audio['sample_width'])
     stream = self.pyaudio_ins.open(rate=audio['sample_rate'],
                                    channels=audio['channels'],
                                    format=pyaudio_format,
                                    output=True)
     stream.write(audio['recording_values'])
     stream.close()
Пример #20
0
    def load_from_file(cls, wav_file):
        wav = wave.open(wav_file, 'rb')
        audio_data = wav.readframes(wav.getnframes())

        wave_data = WaveData(wav.getnchannels(), wav.getframerate(),
                             pyaudio.get_format_from_width(wav.getsampwidth()))
        sample_size = wav.getsampwidth()
        sample_duration = wav.getnframes() * wav.getframerate()
        sound_wave = generate_sound_wave_from_audio_data(audio_data)
        volume = sound_wave[1].max()

        return cls(wave_data, volume, sample_duration, sample_size, sound_wave)
Пример #21
0
def say(text, notification="Open Assistant"):
    p = pyaudio.PyAudio()

    # open stream (2)
    stream = p.open(format=pyaudio.get_format_from_width(2),
                    channels=1,
                    rate=20000,
                    output=True)
    data = synthesizer.synthesize(text)
    stream.write(data)
    stream.stop_stream()
    stream.close()
Пример #22
0
	def __init__(self, audioformat):
		fps 		= audioformat["fps"]
		nchannels = audioformat["nchannels"]
		nbytes    = audioformat["nbytes"]

		p = pyaudio.PyAudio()
		self.stream = p.open(
			channels  	= nchannels,
			rate 		= fps,
			format 	= pyaudio.get_format_from_width(nbytes),
			output 	= True
		)
Пример #23
0
def play(data):
    try:
        print()
        print("========== »нициализаци¤ аудиоподсистемы ==========")
        audio = pyaudio.PyAudio()
        print("============ »нициализаци¤ завершена ==============")
        print("")

        with wave.open(io.BytesIO(data), 'rb') as wav:
            # Measure number of frames:
            nFrames = int(
                len(data) / wav.getsampwidth() / wav.getnchannels() + 65)
            # Read ALL frames in memory:
            frames = wav.readframes(nFrames)
            # and calculate actual number of frames read...
            nFrames = int(
                len(frames) / wav.getsampwidth() / wav.getnchannels())

            # Calculate wav length in seconds
            waveLen = nFrames / wav.getframerate() + 0.3

            audioStream = audio.open(
                format=pyaudio.get_format_from_width(wav.getsampwidth()),
                channels=wav.getnchannels(),
                rate=wav.getframerate(),
                output=True,
                output_device_index=config.audioOutputDevice,
                frames_per_buffer=nFrames -
                16  #!!! Dirty hack to workaround RPi cracking noise
            )
            audioStream.start_stream()
            startTime = time.time()
            audioStream.write(frames)

            # Wait until played
            while time.time() < startTime + waveLen:
                time.sleep(0.2)
    except Exception as e:
        print(f'Exception playing audio: {e}')
    finally:
        try:
            audioStream.stop_stream()
        except:
            pass
        try:
            audioStream.close()
        except:
            pass
        try:
            audio.terminate()
        except:
            pass
Пример #24
0
def init():
    global pyaudio_obj, stream

    pyaudio_obj = pa.PyAudio()

    stream = pyaudio_obj.open(format=pa.get_format_from_width(SAMPLE_WIDTH),
                              channels=NUM_CHANNELS,
                              rate=FRAME_RATE,
                              input=True,
                              output=True,
                              frames_per_buffer=BLOCK_SIZE,
                              stream_callback=callback)
    stream.start_stream()
Пример #25
0
    def generate_speech(self):
        self.wf.rewind()
        self.input_stream = self.pa.open(format=pyaudio.get_format_from_width(
            self.wf.getsampwidth()),
                                         channels=1,
                                         rate=self.template_rate,
                                         input=True,
                                         stream_callback=self.read_callback)
        if (self.muck_up):
            self.wf.close()
            self.wf = wave.open(
                '/home/justin/auditory-soa/sample-completely-different.wav',
                'rb')

        self.output_stream = self.pa.open(format=pyaudio.get_format_from_width(
            self.wf.getsampwidth()),
                                          channels=1,
                                          rate=self.template_rate,
                                          output=True,
                                          stream_callback=self.write_callback)

        self.template_idx = 0
        self.signal = []
 def start_pre_recorded_audio_stream(self):
     "This function opens the audio stream using a pre-recorded file containing ECG (left channel) and PCG (right channel) signals "
     #open the audio stream here
     self.currentdir = os.getcwd()
     self.recfilename = 'stethoscope_and_ecg_rec_example.wav'
     self.wf = wave.open(
         self.currentdir + '/recordings/' + self.recfilename, 'rb')
     self.audio_instance = audio(channels=self.wf.getnchannels(),
                                 rate=self.wf.getframerate(),
                                 frames_per_buffer=self.frame_size,
                                 format=pyaudio.get_format_from_width(
                                     self.wf.getsampwidth()))
     self.audio_instance.start_pyaudio_pre_recorded(self.wf)
     self.audio_instance.start_stream()
Пример #27
0
        def run_decoder():
            decoder = wake_decoders.get(profile.name)

            if decoder is None:
                logging.info('Loading wake decoder with hmm=%s, dict=%s' %
                             (hmm_path, dict_path))

                decoder_config = pocketsphinx.Decoder.default_config()
                decoder_config.set_string('-hmm', hmm_path)
                decoder_config.set_string('-dict', dict_path)
                decoder_config.set_string('-keyphrase', keyphrase)
                decoder_config.set_float('-kws_threshold', kws_threshold)

                decoder = pocketsphinx.Decoder(decoder_config)
                wake_decoders[profile.name] = decoder

            decoder.start_utt()
            finished_event = threading.Event()

            def stream_callback(data, frame_count, time_info, status):
                decoder.process_raw(data, False, False)
                hyp = decoder.hyp()
                if hyp:
                    decoder.end_utt()
                    logging.debug('Keyphrase detected')
                    finished_event.set()
                    return (data, pyaudio.paComplete)

                return (data, pyaudio.paContinue)

            audio = pyaudio.PyAudio()
            data_format = pyaudio.get_format_from_width(2)
            mic = audio.open(format=data_format,
                             channels=1,
                             rate=16000,
                             input=True,
                             input_device_index=device_index,
                             stream_callback=stream_callback)

            # Block until wake word is detected
            mic.start_stream()
            finished_event.wait()

            # Shut down audio input
            mic.stop_stream()
            mic.close()
            audio.terminate()

            # Pass to next stage
            wake_word_detected()
Пример #28
0
def stream_file_to_dev(pyaud: pyaudio.PyAudio, dev: dict):
    input_file = wave.open(os.getenv("WAVE_INPUT_FILENAME", "input.wav"), "rb")
    output_stream = pyaud.open(
        format=pyaudio.get_format_from_width(input_file.getsampwidth()),
        channels=input_file.getnchannels(),
        output_device_index=dev.get("index"),
        rate=int(dev.get("defaultSampleRate")),
        output=True,
    )
    input_file.close()
    file = open(os.getenv("WAVE_INPUT_FILENAME", "input.wav"), "rb")
    semaphore.release()
    output_stream.write(file.read())
    file.close()
Пример #29
0
 def get_stream(self):
     """
     Open pyaudio stream
     :returns pyaudio: Stream object
     """
     stream = self.pyaudio.open(format=pyaudio.get_format_from_width(
         self.width),
                                channels=self.channels,
                                rate=self.sample_rate,
                                input=True,
                                frames_per_buffer=self.sample_chunks,
                                input_device_index=self.index,
                                stream_callback=self.callback)
     return stream
Пример #30
0
    def __init__(self,
                 byte_data,
                 sample_rate,
                 bit_width,
                 channels,
                 dtype=None):
        """
        byte_data: A byte string containing the raw data.
        BIT_WIDTH: bit width in bytes.
        """

        assert isinstance(bit_width, (int, long)) and bit_width > 0, \
                "`bit_width` must be positive integer."
        bit_width = pyaudio.get_sample_size(
            pyaudio.get_format_from_width(bit_width))

        assert isinstance(channels, int) and channels in [1, 2], \
                "`channels` can be either 1(mono) or 2(stereo)."
        assert channels in (1, 2), \
                "`channels` can be either 1(mono) or 2(stereo) only."

        assert sample_rate > 0, "`sample_rate` must be positive."

        self.__bit_width = bit_width
        self.__channels = channels
        self.__sample_rate = sample_rate
        self.__byte_data = byte_data  # a byte string

        if dtype is None:
            dtype = self._get_dtype_by_bit_width()

        if not self._validate_dtype(dtype):
            raise ValueError("`dtype` is not compatible with the `bit_width`.")

        self.__dtype = dtype
        self.format = pyaudio.get_format_from_width(self.BIT_WIDTH)
Пример #31
0
def run(filename, chunk, led):
    wf = wave.open(filename, 'rb')

    pyaudio_format = pyaudio.get_format_from_width(wf.getsampwidth())
    if pyaudio_format == pyaudio.paInt16:
        width = np.int16
    else:
        sys.exit("add a mapping from this pyaudio format to width")

    with audio_stream(wf) as stream:
        data = wf.readframes(chunk)
        while data != '':
            stream.write(data)
            light_io(led, np.fromstring(data, dtype=width))
            data = wf.readframes(chunk)
Пример #32
0
    def __init__(self, filename, chunk=1024):
        self.filename = filename
        self.wavfile = wave.open(self.filename, 'rb')

        audio_format = pyaudio.get_format_from_width(
            self.wavfile.getsampwidth())
        sample_rate = self.wavfile.getframerate()
        channels = self.wavfile.getnchannels()

        super(AudioStreamFile, self).__init__(audio_format,
                                              sample_rate,
                                              channels,
                                              chunk,
                                              audio_input=False,
                                              audio_output=True)
Пример #33
0
def echo(data, channels = 1, rate = 8000, sampwidth = 4):
    """Echo speech signal from wave data.

    :param data: the wave data
    :param channel: wave channels(single or stereo)
    :param rate: sample rate
    :returns: None"""
    pa = pyaudio.PyAudio()
    stream = pa.open(format = pyaudio.get_format_from_width(sampwidth),
                     channels = channels,
                     rate = rate,
                     output = True)

    stream.write(data, len(data))
    stream.stop_stream()
    stream.close()
    pa.terminate()
Пример #34
0
 def stream_audio(self):
     pya = pyaudio.PyAudio()
     audio_stream = pya.open(
         format=pyaudio.get_format_from_width(self._sample_width),
         channels=self._number_of_channels,
         rate=self._sample_rate,
         output=True,
         stream_callback=self._get_next_buffer,
         frames_per_buffer=BUFFER_SIZE,
     )
     audio_stream.start_stream()
     try:
         yield audio_stream
     finally:
         audio_stream.stop_stream()
         audio_stream.close()
         pya.terminate()
Пример #35
0
 def __init__(self, wave_samplewidth, wave_channels, wave_rate,
              initial_buffer_size, processed_data_handler):
     self._stream = audio.open(
         format=pyaudio.get_format_from_width(wave_samplewidth),
         channels=wave_channels,
         rate=wave_rate,
         frames_per_buffer=CHUNK_SIZE,
         output=True,
         stream_callback=self.callback)
     self._buffer_size = initial_buffer_size
     self._processed_data_handler = processed_data_handler
     self._play_lock = threading.Lock()
     self._add_lock = threading.Lock()
     self._play_lock.acquire()
     self._buffer = []
     self._is_playing = False
     self._finish = False
Пример #36
0
def record_sound(s):
	audio = pyaudio.PyAudio()
	stream = audio.open(input = True,
						output = True,
						frames_per_buffer = CHUNK_SIZE,
						channels = CHANNELS,
						rate = RATE,
						format = pyaudio.get_format_from_width(BIT_WIDTH))
	frames = []
	for _ in range(s):
		data_buffer = stream.read(CHUNK_SIZE)
		stream.write(data_buffer)
		frames.append(data_buffer)

	data = b''.join(frames)
	stream.stop_stream()
	stream.close()
	return data
Пример #37
0
    def __init__(self,
                 device_index,
                 sample_rate,
                 bit_width,
                 chunk_size=8092,
                 channels=1):

        audio = pyaudio.PyAudio()
        ## Checking the device_index is valid or not.
        assert isinstance(device_index,
                          (int, long)), "Device index must be an integer."
        device_count = audio.get_device_count()
        assert 0 <= device_index < device_count, "`device_index` out of range: {} out of {}".format(
            device_index, count)
        audio.terminate()
        self.__device_index = device_index

        if not self.device_info["maxInputChannels"] > 0:
            raise DeviceTypeError("Can not source from a non-input device.")

        self.__format = pyaudio.get_format_from_width(bit_width)
        self.__bit_width = pyaudio.get_sample_size(self.FORMAT)

        assert isinstance(sample_rate,
                          (int, long)), "`sample_rate` must be integer."

        max_sample_rate = self.device_info["defaultSampleRate"]
        assert 0 < sample_rate <= max_sample_rate, "`sample_rate` out of range: {} out of {}".format(
            sample_rate, max_sample_rate)
        self.__sample_rate = sample_rate

        assert isinstance(chunk_size,
                          (int, long)), "`chunk_size` must be integer."
        self.__chunk_size = chunk_size

        assert channels in [
            1, 2
        ], '`channels` can be either 1 or 2. 1 for mono audio, 2 for stereo.'
        self.__channels = channels

        # audio resource and streams.
        self.__audio = None
        self.__input_stream = None
Пример #38
0
    def send(self, messageType, message):
        freqArr = self.getFreqs(message)

        # Create new .wav file
        wFile = wave.open('message.wav', 'w')

        # Set it up
        wFile.setparams((1, 2, self.sampleRate, 0, 'NONE', 'not compressed'))
        wData = ""

        # Add data
        for note in freqArr:
            for sample in range(0, int(self.sampleRate*(self.notelength))):

                wData += struct.pack('h', self.volume*(math.sin(2*sample*note*math.pi/(self.sampleRate))))

        # Close and reopen in read mode
        wFile.writeframes(wData)
        wFile.close()
        wFile = wave.open('message.wav','rb')

        # Define stream chunk
        chunk = 1024
        p = pyaudio.PyAudio()

        # Open stream
        stream = p.open(format = pyaudio.get_format_from_width(wFile.getsampwidth()), channels = wFile.getnchannels(), rate = wFile.getframerate(), output = True)
        data = wFile.readframes(chunk)

        #play stream
        while data != '':
            stream.write(data)
            data = wFile.readframes(chunk)

        #stop stream
        stream.stop_stream()
        stream.close()

        #close PyAudio and clean up
        p.terminate()
        wFile.close()
        os.remove('message.wav')
Пример #39
0
def play_audio(audio, fs):
    '''
    plays single channel audio data
    '''
    p = pyaudio.PyAudio()

    datatype = audio.dtype
    #print datatype
    if datatype == np.int8:
        width = 1
    elif datatype == np.int16:
        width = 2
    elif datatype == np.int32:
        width = 4
    elif datatype == np.float32:
        width = 4

    output_format = pyaudio.get_format_from_width(width, False)
    stream = p.open(format=output_format, channels=1, rate=fs, output=True)
    stream.write(audio.tostring())
    def play(self, data, nLoop=inf):
        self.stop()

        data = reshape(data, [-1, self.nChannels], order='F')

        framesPerBuffer = round(self.OUTPUT_BUFFER_LENGTH * self.sampleRate)
        nDataFrames = shape(data)[0]

        data = self.encodeData(data)
        data = repeat(data, ceil(framesPerBuffer / nDataFrames))

        callback = self.createPlayCallback(data, nLoop * nDataFrames)

        self.outputStream = self.session.open(
            format=pyaudio.get_format_from_width(self.sampleSize, unsigned=False),
            channels=self.nChannels,
            rate=self.sampleRate,
            output=True,
            output_device_index=self.deviceIdx,
            stream_callback=callback,
            frames_per_buffer=framesPerBuffer)
        self.outputStream.start_stream()
Пример #41
0
def main(text):
    # Instantiates a client
    client = texttospeech.TextToSpeechClient()

    # Set the text input to be synthesized
    synthesis_input = texttospeech.SynthesisInput(text=text)

    # Build the voice request, select the language code ("en-US") and the ssml
    # voice gender ("neutral")
    voice = texttospeech.VoiceSelectionParams(
        language_code="ko-KR",
        ssml_gender=texttospeech.SsmlVoiceGender.NEUTRAL)

    # Select the type of audio file you want returned
    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.LINEAR16)

    # Perform the text-to-speech request on the text input with the selected
    # voice parameters and audio file type
    response = client.synthesize_speech(input=synthesis_input,
                                        voice=voice,
                                        audio_config=audio_config)

    # response.audio_content is a byte string
    with wave.open(io.BytesIO(response.audio_content), 'rb') as f:
        width = f.getsampwidth()
        channels = f.getnchannels()
        rate = f.getframerate()
    pa = pyaudio.PyAudio()
    pa_stream = pa.open(format=pyaudio.get_format_from_width(width),
                        channels=channels,
                        rate=rate,
                        output=True)

    pa_stream.write(response.audio_content)


# if __name__ == "__main__":
#     main()
    def record(self, t):
        framesPerBuffer = round(self.INPUT_BUFFER_LENGTH * self.sampleRate)

        nDataFrames = round(t * self.sampleRate)
        nWarmupFrames = framesPerBuffer
        nTotalFrames = nDataFrames + nWarmupFrames

        inputStream = self.session.open(
                format=pyaudio.get_format_from_width(self.sampleSize, unsigned=False),
                channels=self.nChannels,
                rate=self.sampleRate,
                input=True,
                input_device_index=self.deviceIdx,
                frames_per_buffer=framesPerBuffer)

        data = []
        iFrame = 0
        while iFrame < nTotalFrames:
            dataTmp = inputStream.read(framesPerBuffer)
            dataTmp = fromstring(dataTmp, dtype=uint8)
            data.append(dataTmp)
            iFrame += framesPerBuffer

        data = array(data, dtype='uint8')

        inputStream.stop_stream()
        inputStream.close()

        data = self.decodeData(data)

        data = data[nWarmupFrames:,:]
        data = data[:nDataFrames,:]

        data = data.flatten(order='F').tolist()

        return data
Пример #43
0
    def __init__(self, filename: str, metre: float, q: Manager().Queue,
                 *, loop: bool=False):
        self.filename = filename
        self.q = q
        self.wf = open_wav(self.filename, "rb")
        self.formatting = get_format_from_width(self.wf.getsampwidth())
        self.channels = self.wf.getnchannels()
        self.no_frames = self.wf.getnframes()
        self.rate = self.wf.getframerate()
        self.data = self.wf.readframes(self.no_frames)
        self.duration = self.no_frames/self.rate
        self.wf.close()

        self.qs = []
        self.processes_pointers = []
        if not loop:
            self.no_p = int(self.duration*metre*10)+2
            self.qs = [Queue() for _ in range(self.no_p)]
            self.ps = [Process(
                target=self.throw_process,
                args=(q,))
                       for q in self.qs]
            self.setup()
            self.i = 0
Пример #44
0
import pyaudio
WIDTH=2
p = pyaudio.PyAudio()
format_pyaudio_int = pyaudio.paInt16 
NUM_CHANNEL_INT = 1
FS = 16000
LENGTH_BUFFER_INT = 2
stream = p.open(format=format_pyaudio_int, channels=NUM_CHANNEL_INT,
rate=FS,
input=False,
output=True,
frames_per_buffer=LENGTH_BUFFER_INT)
# print pyaudio.paInt16
print pyaudio.paInt8
print pyaudio.get_format_from_width(1, unsigned=False)
# print pyaudio.get_format_from_width(WIDTH)
Пример #45
0
	args = parser.parse_args()
	output_file =  args.out
	n = args.n

	CHUNK_SIZE = 8092
	RATE = 44100
	BIT_WIDTH = 2
	CHANNELS = 1

	audio = pyaudio.PyAudio()

	input_stream = audio.open(input = True,
							  frames_per_buffer = CHUNK_SIZE,
							  channels = CHANNELS,
							  rate = RATE,
							  format = pyaudio.get_format_from_width(BIT_WIDTH))
	frames = []
	for _ in range(n):
		data_buffer = input_stream.read(CHUNK_SIZE)
		frames.append(data_buffer)

	input_stream.stop_stream()
	input_stream.close()
	data = b''.join(frames)
	wav_writer = wave.open(output_file, "wb")
	wav_writer.setframerate(RATE)
	wav_writer.setsampwidth(BIT_WIDTH)
	wav_writer.setnchannels(CHANNELS)
	wav_writer.writeframes(data)
	wav_writer.close()
	audio.terminate()