def load(filename): """ Load a wave file and return the signal, sample rate and number of channels. Can be any format supported by the underlying library (libsndfile or SciPy) """ if wav_loader == 'pysoundfile': sf = SoundFile(filename) signal = sf.read() channels = sf.channels sample_rate = sf.samplerate samples = len(sf) file_format = sf.format_info + ' ' + sf.subtype_info sf.close() elif wav_loader == 'scikits.audiolab': sf = Sndfile(filename, 'r') signal = sf.read_frames(sf.nframes) channels = sf.channels sample_rate = sf.samplerate samples = sf.nframes file_format = sf.format sf.close() elif wav_loader == 'scipy.io.wavfile': sample_rate, signal = read(filename) try: channels = signal.shape[1] except IndexError: channels = 1 samples = signal.shape[0] file_format = str(signal.dtype) return signal, sample_rate, channels
def readWave(audio_path, start_frame, end_frame, mono=True, sample_rate=None, clip=True): snd_file = SoundFile(audio_path, mode='r') inf = snd_file._info audio_sr = inf.samplerate snd_file.seek(start_frame) audio = snd_file.read(end_frame - start_frame, dtype='float32') snd_file.close() audio = audio.T # Tuple to numpy, transpose axis to (channels, frames) # Convert to mono if desired if mono and len(audio.shape) > 1 and audio.shape[0] > 1: audio = np.mean(audio, axis=0) # Resample if needed if sample_rate is not None and sample_rate != audio_sr: audio = librosa.resample(audio, audio_sr, sample_rate, res_type="kaiser_fast") audio_sr = sample_rate # Clip to [-1,1] if desired if clip: audio = np.minimum(np.maximum(audio, -1.0), 1.0) return audio, audio_sr
def load_dict(filename): """ Load a wave file and return the signal, sample rate and number of channels. Can be any format supported by the underlying library (libsndfile or SciPy) """ soundfile = {} if wav_loader == 'pysoundfile': sf = SoundFile(filename) soundfile['signal'] = sf.read() soundfile['channels'] = sf.channels soundfile['fs'] = sf.samplerate soundfile['samples'] = len(sf) soundfile['format'] = sf.format_info + ' ' + sf.subtype_info sf.close() elif wav_loader == 'scikits.audiolab': sf = Sndfile(filename, 'r') soundfile['signal'] = sf.read_frames(sf.nframes) soundfile['channels'] = sf.channels soundfile['fs'] = sf.samplerate soundfile['samples'] = sf.nframes soundfile['format'] = sf.format sf.close() elif wav_loader == 'scipy.io.wavfile': soundfile['fs'], soundfile['signal'] = read(filename) try: soundfile['channels'] = soundfile['signal'].shape[1] except IndexError: soundfile['channels'] = 1 soundfile['samples'] = soundfile['signal'].shape[0] soundfile['format'] = str(soundfile['signal'].dtype) return soundfile
def load(filename): """ Load a wave file and return the signal, sample rate and number of channels. Can be any format supported by the underlying library (libsndfile or SciPy) """ if wav_loader == 'pysoundfile': sf = SoundFile(filename) signal = sf.read() channels = sf.channels sample_rate = sf.samplerate sf.close() elif wav_loader == 'scikits.audiolab': sf = Sndfile(filename, 'r') signal = sf.read_frames(sf.nframes) channels = sf.channels sample_rate = sf.samplerate sf.close() elif wav_loader == 'scipy.io.wavfile': sample_rate, signal = read(filename) try: channels = signal.shape[1] except IndexError: channels = 1 return signal, sample_rate, channels
def read_signal(filename, offset=0, nsamples=-1, nchannels=0, offset_is_samples=False): """Read a wavefile and return as numpy array of floats. Args: filename (string): Name of file to read offset (int, optional): Offset in samples or seconds (from start). Defaults to 0. nchannels: expected number of channel (default: 0 = any number OK) offset_is_samples (bool): measurement units for offset (default: False) Returns: ndarray: audio signal """ try: wave_file = SoundFile(filename) except: # Ensure incorrect error (24 bit) is not generated raise Exception(f"Unable to read {filename}.") if nchannels != 0 and wave_file.channels != nchannels: raise Exception( f"Wav file ({filename}) was expected to have {nchannels} channels." ) if wave_file.samplerate != CONFIG.fs: raise Exception(f"Sampling rate is not {CONFIG.fs} for filename {filename}.") if not offset_is_samples: # Default behaviour offset = int(offset * wave_file.samplerate) if offset != 0: wave_file.seek(offset) x = wave_file.read(frames=nsamples) return x
def readWave(audio_path, start_frame, end_frame, mono=True, sample_rate=None, clip=True): snd_file = SoundFile(audio_path, mode='r') inf = snd_file._info audio_sr = inf.samplerate start_read = max(start_frame, 0) pad_front = -min(start_frame, 0) end_read = min(end_frame, inf.frames) pad_back = max(end_frame - inf.frames, 0) snd_file.seek(start_read) audio = snd_file.read(end_read - start_read, dtype='float32', always_2d=True) # (num_frames, channels) snd_file.close() # Pad if necessary (start_frame or end_frame out of bounds) audio = np.pad(audio, [(pad_front, pad_back), (0, 0)], mode="constant", constant_values=0.0) # Convert to mono if desired if mono: audio = np.mean(audio, axis=1, keepdims=True) # Resample if needed if sample_rate is not None and sample_rate != audio_sr: res_length = int( np.ceil( float(audio.shape[0]) * float(sample_rate) / float(audio_sr))) audio = np.pad(audio, [(1, 1), (0, 0)], mode="reflect") # Pad audio first audio = librosa.resample(audio.T, audio_sr, sample_rate, res_type="kaiser_fast").T skip = (audio.shape[0] - res_length) // 2 audio = audio[skip:skip + res_length, :] # Clip to [-1,1] if desired if clip: audio = np.minimum(np.maximum(audio, -1.0), 1.0) return audio, audio_sr
def read_audio_segment(file, pos, length): myfile = SoundFile(file) myfile.seek(pos) audio = myfile.read(length) myfile.close() return audio
def analyze(filename): if wav_loader == 'pysoundfile': sf = SoundFile(filename) signal = sf.read() channels = sf.channels sample_rate = sf.samplerate samples = len(sf) file_format = sf.format_info + ' ' + sf.subtype_info sf.close() elif wav_loader == 'audiolab': sf = Sndfile(filename, 'r') signal = sf.read_frames(sf.nframes) channels = sf.channels sample_rate = sf.samplerate samples = sf.nframes file_format = sf.format sf.close() elif wav_loader == 'scipy': sample_rate, signal = read(filename) try: channels = signal.shape[1] except IndexError: channels = 1 samples = signal.shape[0] file_format = str(signal.dtype) # Scale common formats # Other bit depths (24, 20) are not handled by SciPy correctly. if file_format == 'int16': signal = signal.astype(float) / (2**15) elif file_format == 'uint8': signal = (signal.astype(float) - 128) / (2**7) elif file_format == 'int32': signal = signal.astype(float) / (2**31) elif file_format == 'float32': pass else: raise Exception("Don't know how to handle file " "format {}".format(file_format)) else: raise Exception("wav_loader has failed") header = 'dBFS values are relative to a full-scale square wave' if samples / sample_rate >= 1: length = str(samples / sample_rate) + ' seconds' else: length = str(samples / sample_rate * 1000) + ' milliseconds' results = [ 'Properties for "' + filename + '"', str(file_format), 'Channels:\t%d' % channels, 'Sampling rate:\t%d Hz' % sample_rate, 'Samples:\t%d' % samples, 'Length: \t' + length, '-----------------', ] if channels == 1: # Monaural results += properties(signal, sample_rate) elif channels == 2: # Stereo if array_equal(signal[:, 0], signal[:, 1]): results += ['Left and Right channels are identical:'] results += properties(signal[:, 0], sample_rate) else: results += ['Left channel:'] results += properties(signal[:, 0], sample_rate) results += ['Right channel:'] results += properties(signal[:, 1], sample_rate) else: # Multi-channel for ch_no, channel in enumerate(signal.transpose()): results += ['Channel %d:' % (ch_no + 1)] results += properties(channel, sample_rate) display(header, results) plot_histogram = False if plot_histogram: histogram(signal)
def readAudio(audio_path, offset=0.0, duration=None, mono=True, sample_rate=None, clip=True, padding_duration=0.0, metadata=None): ''' Reads an audio file wholly or partly, and optionally converts it to mono and changes sampling rate. By default, it loads the whole audio file. If the offset is set to None, the duration HAS to be not None, and the offset is then randomly determined so that a random section of the audio is selected with the desired duration. Optionally, the file can be zero-padded by a certain amount of seconds at the start and end before selecting this random section. :param audio_path: Path to audio file :param offset: Position in audio file (s) where to start reading. If None, duration has to be not None, and position will be randomly determined. :param duration: How many seconds of audio to read :param mono: Convert to mono after reading :param sample_rate: Convert to given sampling rate if given :param padding_duration: Amount of padding (s) on each side that needs to be filled up with silence if it isn't available :param metadata: metadata about audio file, accelerates reading audio since duration does not need to be determined from file :return: Audio signal, Audio sample rate ''' if os.path.splitext(audio_path)[1][1:].lower( ) == "mp3": # If its an MP3, call ffmpeg with offset and duration parameters # Get mp3 metadata information and duration if metadata is None: audio_sr, audio_channels, audio_duration = Metadata.get_mp3_metadata( audio_path) else: audio_sr = metadata[0] audio_channels = metadata[1] audio_duration = metadata[2] print(audio_duration) pad_front_duration = 0.0 pad_back_duration = 0.0 if offset is None: # In this case, select random section of audio file assert (duration is not None) max_start_pos = audio_duration + 2 * padding_duration - duration if ( max_start_pos <= 0.0 ): # If audio file is longer than duration of desired section, take all of it, will be padded later print("WARNING: Audio file " + audio_path + " has length " + str(audio_duration) + " but is expected to be at least " + str(duration)) return librosa.load( audio_path, sample_rate, mono, res_type='kaiser_fast') # Return whole audio file start_pos = np.random.uniform( 0.0, max_start_pos ) # Otherwise randomly determine audio section, taking padding on both sides into account offset = max(start_pos - padding_duration, 0.0) # Read from this position in audio file pad_front_duration = max(padding_duration - start_pos, 0.0) assert (offset is not None) if duration is not None: # Adjust duration if it overlaps with end of track pad_back_duration = max(offset + duration - audio_duration, 0.0) duration = duration - pad_front_duration - pad_back_duration # Subtract padding from the amount we have to read from file else: # None duration: Read from offset to end of file duration = audio_duration - offset pad_front_frames = int(pad_front_duration * float(audio_sr)) pad_back_frames = int(pad_back_duration * float(audio_sr)) args = [ 'ffmpeg', '-noaccurate_seek', '-ss', str(offset), '-t', str(duration), '-i', audio_path, '-f', 's16le', '-' ] audio = [] process = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=open(os.devnull, 'wb')) num_reads = 0 while True: output = process.stdout.read(4096) if output == '' and process.poll() is not None: break if output: audio.append( librosa.util.buf_to_float(output, dtype=np.float32)) num_reads += 1 audio = np.concatenate(audio) if audio_channels > 1: audio = audio.reshape((-1, audio_channels)).T else: #Not an MP3: Handle with PySoundFile # open audio file snd_file = SoundFile(audio_path, mode='r') inf = snd_file._info audio_sr = inf.samplerate if duration is not None: num_frames = int(duration * float(audio_sr)) pad_frames = int(padding_duration * float(audio_sr)) pad_front_frames = 0 pad_back_frames = 0 if offset is None: # In this case, select random section of audio file assert (duration is not None) max_start_pos = inf.frames + 2 * pad_frames - num_frames if ( max_start_pos <= 0 ): # If audio file is longer than duration of desired section, take all of it, will be padded later print("WARNING: Audio file " + audio_path + " has frames " + str(inf.frames) + " but is expected to be at least " + str(num_frames)) return librosa.load( audio_path, sample_rate, mono, res_type='kaiser_fast') # Return whole audio file start_pos = np.random.randint( 0, max_start_pos ) # Otherwise randomly determine audio section, taking padding on both sides into account start_frame = max(start_pos - pad_frames, 0) # Read from this position in audio file pad_front_frames = max(pad_frames - start_pos, 0) else: start_frame = int(offset * float(audio_sr)) if duration is not None: # Adjust duration if it overlaps with end of track pad_back_frames = max(start_frame + num_frames - inf.frames, 0) num_frames = num_frames - pad_front_frames - pad_back_frames else: # Duration is None => Read from start frame to end of track num_frames = inf.frames - start_frame snd_file.seek(start_frame) audio = snd_file.read(num_frames, dtype='float32') snd_file.close() audio = audio.T # Tuple to numpy, transpose axis to (channels, frames) centre_start_frame = start_frame - pad_front_frames + pad_frames centre_end_frame = start_frame + num_frames + pad_back_frames - pad_frames # AT THIS POINT WE HAVE A [N_CHANNELS, N_SAMPLES] NUMPY ARRAY FOR THE AUDIO # Pad as indicated at beginning and end if len(audio.shape) > 1: audio = np.pad(audio, [(0, 0), (pad_front_frames, pad_back_frames)], mode="constant", constant_values=0.0) else: audio = np.pad(audio, [(pad_front_frames, pad_back_frames)], mode="constant", constant_values=0.0) # Convert to mono if desired if mono and len(audio.shape) > 1 and audio.shape[0] > 1: audio = np.mean(audio, axis=0) # Resample if needed if sample_rate is not None and sample_rate != audio_sr: audio = librosa.resample(audio, audio_sr, sample_rate, res_type="kaiser_fast") audio_sr = sample_rate # Clip to [-1,1] if desired if clip: audio = np.minimum(np.maximum(audio, -1.0), 1.0) if float(audio.shape[0]) / float(sample_rate) < 1.0: print("----------------------ERROR------------------") if os.path.splitext(audio_path)[1][1:].lower() == "mp3": return audio, audio_sr else: return audio, audio_sr, centre_start_frame, centre_end_frame
def readAudio(audio_path, offset=0.0, duration=None, mono=True, sample_rate=None, clip=True, pad_frames=0, metadata=None): ''' Reads an audio file wholly or partly, and optionally converts it to mono and changes sampling rate. By default, it loads the whole audio file. If the offset is set to None, the duration HAS to be not None, and the offset is then randomly determined so that a random section of the audio is selected with the desired duration. Optionally, the file can be zero-padded by a certain amount of seconds at the start and end before selecting this random section. :param audio_path: Path to audio file :param offset: Position in audio file (s) where to start reading. If None, duration has to be not None, and position will be randomly determined. :param duration: How many seconds of audio to read :param mono: Convert to mono after reading :param sample_rate: Convert to given sampling rate if given :param pad_frames: number of frames with wich to pad the audio at most if the samples at the borders are not available :param metadata: metadata about audio file, accelerates reading audio since duration does not need to be determined from file :return: Audio signal, Audio sample rate ''' if os.path.splitext(audio_path)[1][1:].lower( ) == "mp3": # If its an MP3, call ffmpeg with offset and duration parameters # Get mp3 metadata information and duration if metadata is None: audio_sr, audio_channels, audio_duration = Metadata.get_mp3_metadata( audio_path) else: audio_sr = metadata[0] audio_channels = metadata[1] audio_duration = metadata[2] print(audio_duration) pad_front_duration = 0.0 pad_back_duration = 0.0 ref_sr = sample_rate if sample_rate is not None else audio_sr padding_duration = float(pad_frames) / float(ref_sr) if offset is None: # In this case, select random section of audio file assert (duration is not None) max_start_pos = audio_duration + 2 * padding_duration - duration if ( max_start_pos <= 0.0 ): # If audio file is longer than duration of desired section, take all of it, will be padded later print("WARNING: Audio file " + audio_path + " has length " + str(audio_duration) + " but is expected to be at least " + str(duration)) return Utils.load(audio_path, sample_rate, mono) # Return whole audio file start_pos = np.random.uniform( 0.0, max_start_pos ) # Otherwise randomly determine audio section, taking padding on both sides into account offset = max(start_pos - padding_duration, 0.0) # Read from this position in audio file pad_front_duration = max(padding_duration - start_pos, 0.0) assert (offset is not None) if duration is not None: # Adjust duration if it overlaps with end of track pad_back_duration = max(offset + duration - audio_duration, 0.0) duration = duration - pad_front_duration - pad_back_duration # Subtract padding from the amount we have to read from file else: # None duration: Read from offset to end of file duration = audio_duration - offset pad_front_frames = int(pad_front_duration * float(audio_sr)) pad_back_frames = int(pad_back_duration * float(audio_sr)) args = [ 'ffmpeg', '-noaccurate_seek', '-ss', str(offset), '-t', str(duration), '-i', audio_path, '-f', 's16le', '-' ] audio = [] process = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=open(os.devnull, 'wb')) num_reads = 0 while True: output = process.stdout.read(4096) if output == '' and process.poll() is not None: break if output: audio.append( librosa.util.buf_to_float(output, dtype=np.float32)) num_reads += 1 audio = np.concatenate(audio) if audio_channels > 1: audio = audio.reshape((-1, audio_channels)).T else: #Not an MP3: Handle with PySoundFile # open audio file snd_file = SoundFile(audio_path, mode='r') inf = snd_file._info audio_sr = inf.samplerate pad_orig_frames = pad_frames if sample_rate is None else int( np.ceil( float(pad_frames) * (float(audio_sr) / float(sample_rate)))) pad_front_frames = 0 pad_back_frames = 0 if offset is not None and duration is not None: start_frame = int(offset * float(audio_sr)) read_frames = int(duration * float(audio_sr)) elif offset is not None and duration is None: start_frame = int(offset * float(audio_sr)) read_frames = inf.frames - start_frame else: # In this case, select random section of audio file assert (offset is None) assert (duration is not None) num_frames = int(duration * float(audio_sr)) max_start_pos = inf.frames - num_frames # Maximum start position when ignoring padding on both ends of the file if ( max_start_pos <= 0 ): # If audio file is longer than duration of desired section, take all of it, will be padded later print("WARNING: Audio file " + audio_path + " has frames " + str(inf.frames) + " but is expected to be at least " + str(num_frames)) raise Exception( "Could not read minimum required amount of audio data") #return Utils.load(audio_path, sample_rate, mono) # Return whole audio file start_pos = np.random.randint( 0, max_start_pos ) # Otherwise randomly determine audio section, taking padding on both sides into account # Translate source position into mixture input positions (take into account padding) start_mix_pos = start_pos - pad_orig_frames num_mix_frames = num_frames + 2 * pad_orig_frames end_mix_pos = start_mix_pos + num_mix_frames # Now see how much of the mixture is available, pad the rest with zeros start_frame = max(start_mix_pos, 0) end_frame = min(end_mix_pos, inf.frames) read_frames = end_frame - start_frame pad_front_frames = -min(start_mix_pos, 0) pad_back_frames = max(end_mix_pos - inf.frames, 0) assert (num_frames > 0) snd_file.seek(start_frame) audio = snd_file.read(read_frames, dtype='float32', always_2d=True) snd_file.close() centre_start_frame = start_pos centre_end_frame = start_pos + num_frames # Pad as indicated at beginning and end audio = np.pad(audio, [(pad_front_frames, pad_back_frames), (0, 0)], mode="constant", constant_values=0.0) # Convert to mono if desired if mono: audio = np.mean(audio, axis=1, keepdims=True) # Resample if needed if sample_rate is not None and sample_rate != audio_sr: audio = Utils.resample(audio, audio_sr, sample_rate) # Clip to [-1,1] if desired if clip: audio = np.minimum(np.maximum(audio, -1.0), 1.0) if float(audio.shape[0]) / float(sample_rate) < 1.0: raise IOError("Error while reading " + audio_path + " - ended up with audio shorter than one second!") if os.path.splitext(audio_path)[1][1:].lower() == "mp3": return audio, audio_sr, offset, offset + duration else: return audio, audio_sr, centre_start_frame, centre_end_frame, start_mix_pos, end_mix_pos
def analyze(filename): if wav_loader == 'pysoundfile': sf = SoundFile(filename) signal = sf.read() channels = sf.channels sample_rate = sf.samplerate samples = len(sf) file_format = sf.format_info + ' ' + sf.subtype_info sf.close() elif wav_loader == 'scikits.audiolab': sf = Sndfile(filename, 'r') signal = sf.read_frames(sf.nframes) channels = sf.channels sample_rate = sf.samplerate samples = sf.nframes file_format = sf.format sf.close() elif wav_loader == 'scipy.io.wavfile': sample_rate, signal = read(filename) try: channels = signal.shape[1] except IndexError: channels = 1 samples = signal.shape[0] file_format = str(signal.dtype) # Scale common formats # Other bit depths (24, 20) are not handled by SciPy correctly. if file_format == 'int16': signal = signal.astype(float) / (2**15) elif file_format == 'uint8': signal = (signal.astype(float) - 128) / (2**7) elif file_format == 'int32': signal = signal.astype(float) / (2**31) elif file_format == 'float32': pass else: raise Exception("Don't know how to handle file " "format {}".format(file_format)) else: raise Exception("wav_loader has failed") header = 'dBFS values are relative to a full-scale square wave' if samples/sample_rate >= 1: length = str(samples/sample_rate) + ' seconds' else: length = str(samples/sample_rate*1000) + ' milliseconds' results = [ "Using sound file backend '" + wav_loader + "'", 'Properties for "' + filename + '"', str(file_format), 'Channels:\t%d' % channels, 'Sampling rate:\t%d Hz' % sample_rate, 'Samples:\t%d' % samples, 'Length: \t' + length, '-----------------', ] if channels == 1: # Monaural results += properties(signal, sample_rate) elif channels == 2: # Stereo if array_equal(signal[:, 0], signal[:, 1]): results += ['Left and Right channels are identical:'] results += properties(signal[:, 0], sample_rate) else: results += ['Left channel:'] results += properties(signal[:, 0], sample_rate) results += ['Right channel:'] results += properties(signal[:, 1], sample_rate) else: # Multi-channel for ch_no, channel in enumerate(signal.transpose()): results += ['Channel %d:' % (ch_no + 1)] results += properties(channel, sample_rate) display(header, results) plot_histogram = False if plot_histogram: histogram(signal)
from soundfile import SoundFile import pyfftw import time import numpy as np import matplotlib.pyplot as plt from helpers import * # Opening audio file, reading frame data and sample rate, and closing file sf = SoundFile('source.wav') data = sf.read() f_s = sf.samplerate sf.close() start = time.time() # Builds FFTW plan from input data my_fft = pyfftw.builders.fft(data) # Genereating frequency values for each bin (frequencies range for 0 to sample rate) freq_bins = [i * (f_s / my_fft.N) for i in range(1, my_fft.N + 1)] # Executing FFT my_fft.execute() # Finding magnitude of each frequency found mags = np.abs(my_fft.output_array) end = time.time() # Showing total execution time and info about audio file and FFT print("Time to plan and execute: {}".format(end - start))
class Decoder: """This class is an interface to read data from an audio file""" def __init__(self, file: str): """Creates an instance of a Decoder source with the given configuration Args: file_name (str): Input file name frames_per_buffer (int): Number of frames per buffer. name (str): Name of the element """ self.__instance = SoundFile(file=file, mode='r') @property def sample_rate(self) -> int: """Return the sampling rate in Hz.""" return self.__instance.samplerate @property def channels(self) -> int: """Return the number of channels.""" return self.__instance.channels @property def file_name(self) -> str: """Return the file name.""" return self.__instance.name @property def frames(self) -> int: """ Number of available frames""" return self.__instance.frames def done(self) -> bool: """Checks if there still data to read from the audio file""" return self.__instance.tell() < self.__instance.frames def start(self): """Starts the streaming""" self.__instance.seek(0) def stop(self): """Stops the streaming by seeking the file to the end""" self.__instance.seek(self.__instance.frames) def timestamp(self): """Returns the current streaming timestamp in seconds""" return self.__instance.tell() / self.__instance.samplerate def seek(self, frames: int): """Set the read position. Args: frames (int): The frame index or offset to seek Returns: The new absolute read/write position in frames """ return self.__instance.seek(frames=frames) def read(self, frames_per_channel: int = -1): """Returns the buffer read from the audio file""" if frames_per_channel is -1: frames_per_channel = self.__instance.frames return self.__instance.read(frames=frames_per_channel, dtype='float32', always_2d=False)
def calc_drscore(filename): data = SoundFile(filename) NblockLen = round(blocklenSec * data.samplerate) NblockIdx = math.ceil(data.frames / NblockLen) Nchannels = data.channels RMS = np.zeros((NblockIdx, Nchannels)) Pk = np.zeros((NblockIdx, Nchannels)) for nn in range(NblockIdx): curData = np.array(data.read(NblockLen), ndmin=2) for cc in range(Nchannels): interim = 2 * (np.power(np.abs(curData[:, cc]), 2)) RMS[nn, cc] = math.sqrt(interim.mean()) Pk[nn, cc] = max(abs(curData[:, cc])) iUpmostBlocks = round(NblockIdx * RMSpercentage * 0.01) RMS.sort(axis=0) Pk.sort(axis=0) RMS[:] = RMS[::-1, :] Pk[:] = Pk[::-1, :] RMS_upmost = RMS[:iUpmostBlocks, :] RMS_total = np.sqrt((np.power(RMS, 2)).mean(axis=0)) pre0 = np.power(RMS_upmost, 2).sum(axis=0) pre1 = np.repeat(iUpmostBlocks, Nchannels, axis=0) pre2 = np.sqrt(pre0 / pre1) DR_score = Pk[NhighestPeak - 1, :] / pre2 RMS_score = RMS_total Peak_score = Pk[0, :] DR_score_log = 20 * np.log10(DR_score) RMS_score_log = 20 * np.log10(RMS_score) Peak_score_log = 20 * np.log10(Peak_score) print() print("DR analysis results:") print("====================") print(filename) print() print(" : ", end="") for n in range(Nchannels): print(" Chann {0:2d} :: ".format(n + 1), end="") print() print("Peak : ", end="") for peak in Peak_score_log: print("{0:7.2f} dB :: ".format(peak), end="") print() print("RMS : ", end="") for rms in RMS_score_log: print("{0:7.2f} dB :: ".format(rms), end="") print() print("DR : ", end="") for dr in DR_score_log: print("{0:7.2f} :: ".format(dr), end="") print() return DR_score_log, Peak_score_log, RMS_score_log