def play_audio(wf:wave.Wave_read): CHUNK = 1024 # instantiate PyAudio (1) p = pyaudio.PyAudio() # open stream (2) stream = p.open(format=p.get_format_from_width(wf.getsampwidth()), channels=wf.getnchannels(), rate=wf.getframerate(), output=True) # read data data = wf.readframes(CHUNK) # play stream (3) while len(data) > 0: stream.write(data) data = wf.readframes(CHUNK) stream.stop_stream() stream.close() p.terminate()
def fourier(audio: wave.Wave_read) -> Tuple[Optional[int], Optional[int]]: """Fourierova analýza vstupních dat, vracející (nejnižší, nejvyšší) frekvenci.""" # data length = audio.getnframes() sample_rate = audio.getframerate() windows_count = length // sample_rate channels = 1 if audio.getnchannels() == 1 else 2 # Stereo (2) vs. Mono (1) frames = sample_rate * windows_count data = np.array(unpack(f"{channels * frames}h", audio.readframes(frames))) if channels == 2: data = merge_channels(data) # amplitudy low, high = None, None for i in range(windows_count): bounds = (i * sample_rate, i * sample_rate + sample_rate) window = data[bounds[0]:bounds[1]] amplitudes = np.abs(np.fft.rfft(window)) average = np.average(amplitudes) # peaks peak = lambda amp: amp >= 20 * average # ze zadání for j in range(len(amplitudes)): amplitude = amplitudes[j] if not peak(amplitude): continue if not low: low = j high = j else: high = j if not any((low, high)): return None, None return (high, low) if high < low else (low, high) # Může být totiž prohozené
def print_audio_samples(wave_read: wave.Wave_read, pos_sec=0, steps=1, length_ms=2_000): rate = wave_read.getframerate() start_frame = rate * pos_sec wave_read.readframes(start_frame) end_frame = start_frame + (rate * length_ms // 1000) print("Reading from = %s to = %s, with step = %s" % (start_frame, end_frame, steps)) string_buffer = [] for i in range(start_frame, end_frame, steps): wave_read.setpos(i) peak = wave_read.readframes(1) string_buffer.append(str(peak[0])) print(','.join(string_buffer))
def read(file: wave.Wave_read): """ Reads file and produces an audiodata from its data Returns that audiodata """ params = file.getparams() frames_number = file.getnframes() frames = file.readframes(frames_number) characters_per_frame = len(frames) // frames_number framesdata = split_frames_into_sounds(frames, characters_per_frame) return AudioData(params, framesdata)
def join(self, inputWavfile: wave.Wave_read, start, end): length = end - start if start < 0 or end < 0 or length < 0: raise ValueError("Invalid start value was given") params = inputWavfile.getparams() if not self.__compareParams(params): raise ValueError("File can not be joined due to inappropriate parameters") else: inputWavfile.setpos(int(start * self.frameRate)) data = inputWavfile.readframes(int(length * self.frameRate)) self.__output.writeframes(data)
def print_audio_samples_all(wave_read: wave.Wave_read): n = wave_read.getnframes() buffer = [] count = 0 for i in range(n): sample = wave_read.readframes(1) int_version = int.from_bytes(sample, byteorder='little') if int_version == 0: count += 1 if i % 100 == 0: # if int_version > (1 << 15): int_version = (1 << 15) - int_version buffer.append(int_version) print(buffer) print(count)
def iter_wav_data(wav: wave.Wave_read, chunk_size: int, min_padding=0): wav.rewind() nchunks = wav.getnframes() // chunk_size for n in range(0, nchunks): d = wav.readframes(chunk_size) if len(d) < chunk_size: d += b'\0\0' * (chunk_size - len(d)) a = array.array('h') a.frombytes(d) yield a if min_padding: a = array.array('h') a.frombytes(b'\0\0'*min_padding) yield a
def filter_lowpassTest(wav: Wave_read, cutoff: int): signal = wav.readframes(-1) signal = np.fromstring(signal, "Int16") filtered: wave.Wave_write = wave.open(join(const.AUDIO_DIR, 'temp.wav'), 'w') filtered.setframerate(wav.getframerate()) filtered.setsampwidth(wav.getsampwidth()) filtered.setnchannels(wav.getnchannels()) for frame in frames: data = struct.pack('<h', frame) filtered.writeframesraw(data) filtered.close() return wave.open(join(const.AUDIO_DIR, 'temp.wav'), 'r')
def trim(sound_file: wave.Wave_read, ratio, new_file_path): """ Creates a new trimmed file out of the given one :param sound_file: Source file :param ratio: The ratio by which the function trims :param new_file_path: Path to the output file """ frame_count = sound_file.getnframes() target_frame_count = int(frame_count * ratio) new_frames = sound_file.readframes(target_frame_count) new_file = wave.open(new_file_path, 'w') new_file.setparams(sound_file.getparams()) new_file.writeframes(new_frames) new_file.close()
def transform_nparray(orignal_wave: wave.Wave_read) -> Tuple[np.ndarray, int]: """transform wave into ndarray Parameters ---------- orignal_wave : file wave_read object Returns ------- narray : ndarray 1-d array narray_frame : int frame_length """ narray_frame = orignal_wave.getnframes() narray = orignal_wave.readframes(narray_frame) narray = np.frombuffer(narray, dtype="int16") return narray, narray_frame
def _send_packet(self, wave_file: wave.Wave_read, first_packet: bool, transport) -> int: frames = wave_file.readframes(FRAMES_PER_PACKET) if not frames: return 0 header = AudioPacketHeader.encode( 0x80, 0xE0 if first_packet else 0x60, self.context.rtpseq, self.context.rtptime, self.context.session_id, ) # ALAC frame with raw data. Not so pretty but will work for now until a # proper ALAC encoder is added. audio = bitarray("00" + str(self.context.channels - 1) + 19 * "0" + "1") for i in range(0, len(frames), 2): audio.frombytes(bytes([frames[i + 1], frames[i]])) if transport.is_closing(): _LOGGER.warning("Connection closed while streaming audio") return 0 packet = header + audio.tobytes() # Add packet to backlog before sending self._packet_backlog[self.context.rtpseq] = packet transport.sendto(packet) self.context.rtpseq = (self.context.rtpseq + 1) % (2**16) self.context.head_ts += int( len(frames) / (self.context.channels * self.context.bytes_per_channel)) return int( len(frames) / (self.context.channels * self.context.bytes_per_channel))
def encode_chunk(self, thread_id: str, file: Wave_read, total_samples_to_read: int, output: BytesIO) -> None: options = STARTUPINFO() options.dwFlags |= subprocess.STARTF_USESHOWWINDOW options.wShowWindow = subprocess.SW_HIDE process = Popen(self.command, stdin=PIPE, stdout=PIPE, stderr=PIPE, startupinfo=options) read_data_thread = Thread( target=lambda: output.write(process.stdout.read())) read_data_thread.daemon = True read_data_thread.start() samples_to_read, samples_left = self.update_samples_to_read( total_samples_to_read, 1024) last_progress = 0 while samples_left > 0: process.stdin.write(file.readframes(samples_to_read)) progress = int((total_samples_to_read - samples_left) * 100 / total_samples_to_read) if progress != last_progress: self.listener.encode_update(thread_id, progress) last_progress = progress samples_to_read, samples_left = self.update_samples_to_read( samples_left, 1024) self.listener.encode_update(thread_id, 100) process.stdin.close() read_data_thread.join() process.stdout.close() process.stderr.close() file.close()