o zi @sddlZddlZddlZddlZddlZddlZddlZddlZddlm Z ddlm Z ddl Z ddl Z ddlZddlZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lm Z e dgdZ! de!j"_#Gdddeeeeeeee Z$dS)N) namedtuple)Path)util) DisplayMixin)DSPMixin) EffectMixin)ImpulseResponseMixin) FFMPEGMixin) LoudnessMixin) PlayMixin) WhisperMixin STFTParams window_length hop_length window_type match_stride padding_typeNNNNNc @s$eZdZdZ     ddejejee e j fde de deded ef d d Zed d Ze   ddejee fdededeje jje ffddZe   ddejee fdede deje jje ffddZe  ddede de de fddZe  ddedede de def dd Ze ! ! ! dd"ed#ed$ed%ed&e f d'd(Z )ddejee fdeded efd*d+Z )dd,ejeje j fde d efd-d.Zdejee ffd/d0Zd1d2Zd3d4Z d5d6Z!d7d8Z"d9d:Z#d;d<Z$de fd=d>Z%d efd?d@Z&dAdBZdCdDZ'dEdFZ(dGdHZ)dIe dJe fdKdLZ*ddMe dNefdOdPZ+dIe dJe fdQdRZ,dSe fdTdUZ-edVdWZ.edXdYZ/e/j0dZejeje j ffd[dYZ/e/Z1ed\d]Z2e2j0dZejeje j ffd^d]Z2ed_d`Z3edadbZ4e4Z5edcddZ6ededfZ7e7Z8edgdhZ9e:e;e>j0doe fdpdnZ>dje dqe drefdsdtZ?     ddje dqe diedreduef dvdwZ@     ddje dqe diedredMe f dxdyZAe:e;>> signal = AudioSignal(torch.randn(5*44100), 44100) Note, the signal is reshaped to have a batch size, and one audio channel: >>> print(signal.shape) (1, 1, 44100) You can treat AudioSignals like tensors, and many of the same functions you might use on tensors are defined for AudioSignals as well: >>> signal.to("cuda") >>> signal.cuda() >>> signal.clone() >>> signal.detach() Indexing AudioSignals returns an AudioSignal: >>> signal[..., 3*44100:4*44100] The above signal is 1 second long, and is also an AudioSignal. Nraudio_path_or_array sample_rate stft_paramsoffsetdurationdevicec Csd}d}t|tr |}nt|tjr|}nt|tjr|}n t|r&|}ntdd|_ d|_ d|_ d|_ |durD|j ||||dn|durX|dusPJd|j|||dd|_||_||d|_dS)NzPaudio_path_or_array must be either a Path, string, numpy array, or torch Tensor!)rrrzMust set sample rate!)rrr) isinstancestrpathlibrnpndarraytorch is_tensor ValueError path_to_file audio_datasources stft_dataload_from_fileload_from_arraywindowrmetadata) selfrrrrrr audio_path audio_arrayr1P/home/ubuntu/.local/lib/python3.10/site-packages/audiotools/core/audio_signal.py__init__zs:      zAudioSignal.__init__cC|jS)zq Path to input file, if it exists. Alias to ``path_to_file`` for backwards compatibility r&r.r1r1r2path_to_input_fileszAudioSignal.path_to_input_filer/statec Ksrt|}|j}t|}|durdn|}t||d} ||| }||f||d|} || jd<|| jd<| S)aRandomly draw an excerpt of ``duration`` seconds from an audio file specified at ``audio_path``, between ``offset`` seconds and end of file. ``state`` can be used to seed the random draw. Parameters ---------- audio_path : typing.Union[str, Path] Path to audio file to grab excerpt from. offset : float, optional Lower bound for the start time, in seconds drawn from the file, by default None. duration : float, optional Duration of excerpt, in seconds, by default None state : typing.Union[np.random.RandomState, int], optional RandomState or seed of random state, by default None Returns ------- AudioSignal AudioSignal containing excerpt. Examples -------- >>> signal = AudioSignal.excerpt("path/to/audio", duration=5) Nrrrr)rinfor random_statemaxuniformr-) clsr/rrr8kwargsr9total_duration lower_bound upper_boundsignalr1r1r2excerpts "    zAudioSignal.excerptloudness_cutoff num_triesc Kst|}|dur|j|fd|i|}|Stj }d}||krB|j|fd|i|}|}|d7}|dur>||kr> |S||ks |S)a6Similar to AudioSignal.excerpt, except it extracts excerpts only if they are above a specified loudness threshold, which is computed via a fast LUFS routine. Parameters ---------- audio_path : typing.Union[str, Path] Path to audio file to grab excerpt from. loudness_cutoff : float, optional Loudness threshold in dB. Typical values are ``-40, -60``, etc, by default None num_tries : int, optional Number of tries to grab an excerpt above the threshold before giving up, by default 8. state : typing.Union[np.random.RandomState, int], optional RandomState or seed of random state, by default None kwargs : dict Keyword arguments to AudioSignal.excerpt Returns ------- AudioSignal AudioSignal containing excerpt. .. warning:: if ``num_tries`` is set to None, ``salient_excerpt`` may try forever, which can result in an infinite loop if ``audio_path`` does not have any loud enough excerpts. Examples -------- >>> signal = AudioSignal.salient_excerpt( "path/to/audio", loudness_cutoff=-40, duration=5 ) Nr8rr)rr:rCr!infloudness) r=r/rErFr8r>rCrHnum_tryr1r1r2salient_excerpts / zAudioSignal.salient_excerptr num_channels batch_sizecKs(t||}|t||||fi|S)axHelper function create an AudioSignal of all zeros. Parameters ---------- duration : float Duration of AudioSignal sample_rate : int Sample rate of AudioSignal num_channels : int, optional Number of channels, by default 1 batch_size : int, optional Batch size, by default 1 Returns ------- AudioSignal AudioSignal containing all zeros. Examples -------- Generate 5 seconds of all zeros at a sample rate of 44100. >>> signal = AudioSignal.zeros(5.0, 44100) )intr#zeros)r=rrrKrLr> n_samplesr1r1r2rN s !zAudioSignal.zerossine frequencyshapec Kst||}td||}|dkr$ddlm} | dtj||d} nM|dkr:ddlm} | dtj||} n7|dkrKtdtj||} n&|d krjddlm} | tj||d} t |  dd } nt d |tj | tj d } | d dd |d } || |fi|S) aO Generate a waveform of a given frequency and shape. Parameters ---------- frequency : float Frequency of the waveform duration : float Duration of the waveform sample_rate : int Sample rate of the waveform num_channels : int, optional Number of channels, by default 1 shape : str, optional Shape of the waveform, by default "saw" One of "sawtooth", "square", "sine", "triangle" kwargs : dict Keyword arguments to AudioSignal rsawtooth)rSg?square)rUrPtrianglerzInvalid shape )dtype)rMr#linspace scipy.signalrSr!pirUsinabsr%tensorfloat32 unsqueezerepeat) r=rQrrrKrRr>rOtrS wave_datarUr1r1r2waveFs$    zAudioSignal.waveF audio_signals pad_signalstruncate_signalsresampledimcCs dd|D}dd|D}tt|dkr-|r%|D] }||dqntd|dtt|dkre|rLt|} |D] }| |j} |d| q=n|r]t|} |D]}|| qTntd|d t j d d|D|d } d d|D} || |dj d }| |_ |S)aCreates a batched AudioSignal from a list of AudioSignals. Parameters ---------- audio_signals : list[AudioSignal] List of AudioSignal objects pad_signals : bool, optional Whether to pad signals to length of the maximum length AudioSignal in the list, by default False truncate_signals : bool, optional Whether to truncate signals to length of shortest length AudioSignal in the list, by default False resample : bool, optional Whether to resample AudioSignal to the sample rate of the first AudioSignal in the list, by default False dim : int, optional Dimension along which to batch the signals. Returns ------- AudioSignal Batched AudioSignal. Raises ------ RuntimeError If not all AudioSignals are the same sample rate, and ``resample=False``, an error is raised. RuntimeError If not all AudioSignals are the same the length, and both ``pad_signals=False`` and ``truncate_signals=False``, an error is raised. Examples -------- Batching a bunch of random signals: >>> signal_list = [AudioSignal(torch.randn(44100), 44100) for _ in range(10)] >>> signal = AudioSignal.batch(signal_list) >>> print(signal.shape) (10, 1, 44100) cSg|]}|jqSr1) signal_length.0xr1r1r2 z%AudioSignal.batch..cSrir1rrkr1r1r2rnrorrz.Not all signals had the same sample rate! Got zH. All signals must have the same sample rate, or resample must be True. z)Not all signals had the same length! Got zU. All signals must be the same length, or pad_signals/truncate_signals must be True. cSrir1r'rkr1r1r2rnro)rhcSrir1r5rkr1r1r2rnrorp) lensetrg RuntimeErrorr;rjzero_padmintruncate_samplesr#catrr&)r=rdrerfrgrhsignal_lengths sample_ratesrm max_lengthpad_len min_lengthr' audio_pathsbatched_signalr1r1r2batch|sB4    zAudioSignal.batchcpucCsddl}|j|||ddd\}}t|}|jddkr*td|d|d|d |jd kr4|d}|jd kr>|d}||_|j |_ ||_ ||_ | |S) aLoads data from file. Used internally when AudioSignal is instantiated with a path to a file. Parameters ---------- audio_path : typing.Union[str, Path] Path to file offset : float Offset in seconds duration : float Duration in seconds device : str, optional Device to put AudioSignal on, by default "cpu" Returns ------- AudioSignal AudioSignal loaded from file rNF)rrsrmonoz Audio file z with offset z and duration z is empty!rT)librosaloadr ensure_tensorrRrtndimr_r'rjoriginal_signal_lengthrr&to)r.r/rrrrdatarr1r1r2r*s,      zAudioSignal.load_from_filer0cCsdt|}|jtjkr|}|jdkr|d}|jdkr#|d}||_|j |_ ||_ | |S)a!Loads data from array, reshaping it to be exactly 3 dimensions. Used internally when AudioSignal is called with a tensor or an array. Parameters ---------- audio_array : typing.Union[torch.Tensor, np.ndarray] Array/tensor of audio of samples. sample_rate : int Sample rate of audio device : str, optional Device to move audio onto, by default "cpu" Returns ------- AudioSignal AudioSignal loaded from array rTrr) rrrWr#doublefloatrr_r'rjrrr)r.r0rrr'r1r1r2r+s       zAudioSignal.load_from_arraycCsJ|jddkrtdtt||jdj |j ||_ |S)aWrites audio to a file. Only writes the audio that is in the very first item of the batch. To write other items in the batch, index the signal along the batch dimension before writing. After writing, the signal's ``path_to_file`` attribute is updated to the new path. Parameters ---------- audio_path : typing.Union[str, Path] Path to write audio to. Returns ------- AudioSignal Returns original AudioSignal, so you can use this in a fluent interface. Examples -------- Creating and writing a signal to disk: >>> signal = AudioSignal(torch.randn(10, 1, 44100), 44100) >>> signal.write("/tmp/out.wav") Writing a different element of the batch: >>> signal[5].write("/tmp/out.wav") Using this in a fluent interface: >>> signal.write("/tmp/original.wav").low_pass(4000).write("/tmp/lowpass.wav") rrz'Audio amplitude > 1 clipped when saving) r'r\r;warningswarn soundfilewriternumpyTrr&)r.r/r1r1r2r6s "  zAudioSignal.writecCs t|S)zCopies the signal and all of its attributes. Returns ------- AudioSignal Deep copy of the audio signal. )copydeepcopyr6r1r1r2r_ zAudioSignal.deepcopycCs t|S)zShallow copy of signal. Returns ------- AudioSignal Shallow copy of the audio signal. )rr6r1r1r2rirzAudioSignal.copycCsht||j|j|jd}|jdur|j|_|jdur$|j|_t|j |_ t|j |_ |S)aClones all tensors contained in the AudioSignal, and returns a copy of the signal with everything cloned. Useful when using AudioSignal within autograd computation graphs. Relevant attributes are the stft data, the audio data, and the loudness of the file. Returns ------- AudioSignal Clone of AudioSignal. rN) typer'clonerrr) _loudnessrrr&r-)r.rr1r1r2rss    zAudioSignal.clonecCs<|jdur |j|_|jdur|j|_|j|_|S)aDetaches tensors contained in AudioSignal. Relevant attributes are the stft data, the audio data, and the loudness of the file. Returns ------- AudioSignal Same signal, but with all tensors detached. N)rdetachr)r'r6r1r1r2rs    zAudioSignal.detachc stjddM|jt}td}t|tjdddt fdddD] }| d |q,Wd n1sBwY| }Wd |S1sVwY|S) aWrites the audio data to a temporary file, and then hashes it using hashlib. Useful for creating a file name based on the audio content. Returns ------- str Hash of audio data. Examples -------- Creating a signal, and writing it to a unique file name: >>> signal = AudioSignal(torch.randn(44100), 44100) >>> hash = signal.hash() >>> signal.write(f"{hash}.wav") z.wav)suffixirbr) bufferingcs SN)readintor1fmvr1r2s z"AudioSignal.hash..N) tempfileNamedTemporaryFilernamehashlibsha256 bytearray memoryviewopeniterupdate hexdigest)r.hbn file_hashr1rr2hashs     zAudioSignal.hashcCs|jjddd|_|S)zConverts audio data to mono audio, by taking the mean along the channels dimension. Returns ------- AudioSignal AudioSignal with mean of channels. rT)keepdim)r'meanr6r1r1r2to_monos zAudioSignal.to_monocCs,||jkr|St|j|j||_||_|S)a:Resamples the audio, using sinc interpolation. This works on both cpu and gpu, and is much faster on gpu. Parameters ---------- sample_rate : int Sample rate to resample to. Returns ------- AudioSignal Resampled AudioSignal )rjulius resample_fracr')r.rr1r1r2rgs  zAudioSignal.resamplecCsL|jdur |j||_|jdur|j||_|jdur$|j||_|S)a{Moves all tensors contained in signal to the specified device. Parameters ---------- device : str Device to move AudioSignal onto. Typical values are "cuda", "cpu", or "cuda:n" to specify the nth gpu. Returns ------- AudioSignal AudioSignal with all tensors moved to specified device. N)rrr)r'r.rr1r1r2rs   zAudioSignal.tocCs|j|_|S)zhCalls ``.float()`` on ``self.audio_data``. Returns ------- AudioSignal )r'rr6r1r1r2rs zAudioSignal.floatcC |dS)zWMoves AudioSignal to cpu. Returns ------- AudioSignal rrr6r1r1r2r zAudioSignal.cpucCr)zXMoves AudioSignal to cuda. Returns ------- AudioSignal cudarr6r1r1r2r rzAudioSignal.cudacCs|jS)zDetaches ``self.audio_data``, moves to cpu, and converts to numpy. Returns ------- np.ndarray Audio data as a numpy array. )r'rrrr6r1r1r2rszAudioSignal.numpybeforeaftercCstjj|j||f|_|S)aLZero pads the audio_data tensor before and after. Parameters ---------- before : int How many zeros to prepend to audio. after : int How many zeros to append to audio. Returns ------- AudioSignal AudioSignal with padding applied. )r#nn functionalpadr'r.rrr1r1r2ruszAudioSignal.zero_padlengthmodecCsH|dkr|t||jdd|S|dkr"|dt||jd|S)aPad with zeros to a specified length, either before or after the audio data. Parameters ---------- length : int Length to pad to mode : str, optional Whether to prepend or append zeros to signal, by default "after" Returns ------- AudioSignal AudioSignal with padding applied. rrr)rur;rj)r.rrr1r1r2 zero_pad_to1s zAudioSignal.zero_pad_tocCs:|dkr|jd|df|_|S|jd|| f|_|S)aNTrims the audio_data tensor before and after. Parameters ---------- before : int How many samples to trim from beginning. after : int How many samples to trim from end. Returns ------- AudioSignal AudioSignal with trimming applied. r.Nrqrr1r1r2trimGs zAudioSignal.trimlength_in_samplescCs|jdd|f|_|S)aTruncate signal to specified length. Parameters ---------- length_in_samples : int Truncate to this many samples. Returns ------- AudioSignal AudioSignal with truncation applied. .Nrq)r.rr1r1r2rw\s zAudioSignal.truncate_samplescCs,|jdur |jj}|S|jdur|jj}|S)zGet device that AudioSignal is on. Returns ------- torch.device Device that AudioSignal is on. N)r'rr)rr1r1r2rls  zAudioSignal.devicecCr4)aReturns the audio data tensor in the object. Audio data is always of the shape (batch_size, num_channels, num_samples). If value has less than 3 dims (e.g. is (num_channels, num_samples)), then it will be reshaped to (1, num_channels, num_samples) - a batch size of 1. Parameters ---------- data : typing.Union[torch.Tensor, np.ndarray] Audio data to set. Returns ------- torch.Tensor Audio samples. ) _audio_datar6r1r1r2r'|szAudioSignal.audio_datarcCs<|durt|s Jd|jdksJd||_d|_dS)Nz!audio_data should be torch.Tensorrz$audio_data should be 3-dim (B, C, T))r#r$rrrr.rr1r1r2r's cCr4)zReturns the STFT data inside the signal. Shape is (batch, channels, frequencies, time). Returns ------- torch.Tensor Complex spectrogram data. ) _stft_datar6r1r1r2r)s zAudioSignal.stft_datacCsL|dur!t|rt|sJ|jdur!|jj|jkr!td||_dS)Nzstft_data changed shape)r#r$ is_complexr)rRrrrrr1r1r2r)s  cC |jjdS)zsBatch size of audio signal. Returns ------- int Batch size of signal. rr'rRr6r1r1r2rL zAudioSignal.batch_sizecCr)zvLength of audio signal. Returns ------- int Length of signal in samples. rrr6r1r1r2rjrzAudioSignal.signal_lengthcCs|jjS)zmShape of audio data. Returns ------- tuple Shape of audio data. rr6r1r1r2rRs zAudioSignal.shapecCs |j|jS)zLength of audio signal in seconds. Returns ------- float Length of signal in seconds. )rjrr6r1r1r2signal_durationrzAudioSignal.signal_durationcCr)zuNumber of audio channels. Returns ------- int Number of audio channels. rrr6r1r1r2rKrzAudioSignal.num_channelsrrcCsdddlm}|dkrt||}n|dkr t|d|}n|||}t|| }|S)aWrapper around scipy.signal.get_window so one can also get the popular sqrt-hann window. This function caches for efficiency using functools.lru\_cache. Parameters ---------- window_type : str Type of window to get window_length : int Length of the window device : str Device to put window onto. Returns ------- torch.Tensor Window returned by scipy.signal.get_window, as a tensor. r)rBaverage sqrt_hannhann) scipyrBr!onessqrt get_windowr# from_numpyrr)rrrrBr,r1r1r2rs  zAudioSignal.get_windowcCr4)aReturns STFTParams object, which can be re-used to other AudioSignals. This property can be set as well. If values are not defined in STFTParams, they are inferred automatically from the signal properties. The default is to use 32ms windows, with 8ms hop length, and the square root of the hann window. Returns ------- STFTParams STFT parameters for the AudioSignal. Examples -------- >>> stft_params = STFTParams(128, 32) >>> signal1 = AudioSignal(torch.randn(44100), 44100, stft_params=stft_params) >>> signal2 = AudioSignal(torch.randn(44100), 44100, stft_params=signal1.stft_params) >>> signal1.stft_params = STFTParams() # Defaults ) _stft_paramsr6r1r1r2rszAudioSignal.stft_paramsvaluec Cstdttd|j}|d}d}d}d}t|||||d}|r*|n|}|D]}||dur<||||<q.tdi||_d|_dS) NrTgMb?rFreflectrr1) rMr!ceillog2rr_asdictrr)) r.rdefault_win_lendefault_hop_lendefault_win_typedefault_match_stridedefault_padding_typedefault_stft_paramskeyr1r1r2r(s*   rrcCsX|j}|r$||dksJdt||||}||d}||fSd}d}||fS)aCompute how the STFT should be padded, based on match\_stride. Parameters ---------- window_length : int Window length of STFT. hop_length : int Hop length of STFT. match_stride : bool Whether or not to match stride, making the STFT have the same alignment as convolutional layers. Returns ------- tuple Amount to pad on either side of audio. rz+For match_stride, hop must equal n_fft // 4rTr)rjmathr)r.rrrr right_padrr1r1r2compute_stft_paddingAs z AudioSignal.compute_stft_paddingrcCs |dur|jjnt|}|dur|jjnt|}|dur |jjn|}|dur*|jjn|}|dur4|jjn|}||||jj }| |jj }|j}| |||\}} t j j|| | |f|}t j|d|jd|||ddd} | j\} } } | |j|j| | } |r| dddf} | |_| S)aComputes the short-time Fourier transform of the audio data, with specified STFT parameters. Parameters ---------- window_length : int, optional Window length of STFT, by default ``0.032 * self.sample_rate``. hop_length : int, optional Hop length of STFT, by default ``window_length // 4``. window_type : str, optional Type of window to use, by default ``sqrt\_hann``. match_stride : bool, optional Whether to match the stride of convolutional layers, by default False padding_type : str, optional Type of padding to use, by default 'reflect' Returns ------- torch.Tensor STFT of audio data. Examples -------- Compute the STFT of an AudioSignal: >>> signal = AudioSignal(torch.randn(44100), 44100) >>> signal.stft() Vary the window and hop length: >>> stft_params = [STFTParams(128, 32), STFTParams(512, 128)] >>> for stft_param in stft_params: >>> signal.stft_params = stft_params >>> signal.stft() NrT)n_fftrr,return_complexcenter.rT)rrrMrrrrrr'rrrr#rrrstftreshaperRrLrKr))r.rrrrrr,r'rrr)_nfntr1r1r2rcsF. zAudioSignal.stftcCs,|jdur td|dur|jjnt|}|dur|jjnt|}|dur)|jjn|}|dur3|jjn|}||||jj }|jj \}}} } |j ||| | } | |||\} } |durh|j }|d| | }|rrtjj| d} tj| ||||dd}| ||d}|r|d| | |  f}||_|S) awComputes inverse STFT and sets it to audio\_data. Parameters ---------- window_length : int, optional Window length of STFT, by default ``0.032 * self.sample_rate``. hop_length : int, optional Hop length of STFT, by default ``window_length // 4``. window_type : str, optional Type of window to use, by default ``sqrt\_hann``. match_stride : bool, optional Whether to match the stride of convolutional layers, by default False length : int, optional Original length of signal, by default None Returns ------- AudioSignal AudioSignal with istft applied. Raises ------ RuntimeError Raises an error if stft was not called prior to istft on the signal, or if stft_data is not set. Nz.Cannot do inverse STFT without self.stft_data!rT)rTrTT)rrr,rrr.)r)rtrrrMrrrrrrRrrrr#rrristftr')r.rrrrrr,nbnchrrr)rrr'r1r1r2rsH "zAudioSignal.istftrrn_melsfminfmaxcCsddlm}||||||dS)a Create a Filterbank matrix to combine FFT bins into Mel-frequency bins. Parameters ---------- sr : int Sample rate of audio n_fft : int Number of FFT bins n_mels : int Number of mels fmin : float, optional Lowest frequency, in Hz, by default 0.0 fmax : float, optional Highest frequency, by default None Returns ------- np.ndarray [shape=(n_mels, 1 + n_fft/2)] Mel transform matrix r)melrrrrr)librosa.filtersr)rrrrrlibrosa_mel_fnr1r1r2get_mel_filterss zAudioSignal.get_mel_filtersPmel_fminmel_fmaxc Ksv|jdi|}t|}|jd}|j|jd|d|||d}t||j}| dd|j } | dd} | S)aComputes a Mel spectrogram. Parameters ---------- n_mels : int, optional Number of mels, by default 80 mel_fmin : float, optional Lowest frequency, in Hz, by default 0.0 mel_fmax : float, optional Highest frequency, by default None kwargs : dict, optional Keyword arguments to self.stft(). Returns ------- torch.Tensor [shape=(batch, channels, mels, time)] Mel spectrogram. rTrrrNr1) rr#r\rRrrrrr transposer) r.rrrr>r magnituder mel_basismel_spectrogramr1r1r2r5s    zAudioSignal.mel_spectrogramorthon_mfccnormcCsddlm}|||||S)aCreate a discrete cosine transform (DCT) transformation matrix with shape (``n_mels``, ``n_mfcc``), it can be normalized depending on norm. For more information about dct: http://en.wikipedia.org/wiki/Discrete_cosine_transform#DCT-II Parameters ---------- n_mfcc : int Number of mfccs n_mels : int Number of mels norm : str Use "ortho" to get a orthogonal matrix or None, by default "ortho" device : str, optional Device to load the transformation matrix on, by default None Returns ------- torch.Tensor [shape=(n_mels, n_mfcc)] T The dct transformation matrix. r) create_dct)torchaudio.functionalr r)r rr rr r1r1r2get_dct[s zAudioSignal.get_dct(ư> log_offsetcKsR|j|fi|}t||}|||d|j}|dd|}|dd}|S)a{Computes mel-frequency cepstral coefficients (MFCCs). Parameters ---------- n_mfcc : int, optional Number of mels, by default 40 n_mels : int, optional Number of mels, by default 80 log_offset: float, optional Small value to prevent numerical issues when trying to compute log(0), by default 1e-6 kwargs : dict, optional Keyword arguments to self.mel_spectrogram(), note that some of them will be used for self.stft() Returns ------- torch.Tensor [shape=(batch, channels, mfccs, time)] MFCCs. rrr)rr#logr rr)r.r rrr>rdct_matmfccr1r1r2rvs  zAudioSignal.mfcccC|jdur |t|jS)aComputes and returns the absolute value of the STFT, which is the magnitude. This value can also be set to some tensor. When set, ``self.stft_data`` is manipulated so that its magnitude matches what this is set to, and modulated by the phase. Returns ------- torch.Tensor Magnitude of STFT. Examples -------- >>> signal = AudioSignal(torch.randn(44100), 44100) >>> magnitude = signal.magnitude # Computes stft if not computed >>> magnitude[magnitude < magnitude.mean()] = 0 >>> signal.magnitude = magnitude >>> signal.istft() N)r)rr#r\r6r1r1r2r  zAudioSignal.magnitudecCs|td|j|_dSNy?)r#expphaser)r.rr1r1r2r?h㈵>T@ ref_valueamintop_dbcCsd|j}|d}dt|dj|d}|dtt||8}|dur0t|||}|S)aComputes the log-magnitude of the spectrogram. Parameters ---------- ref_value : float, optional The magnitude is scaled relative to ``ref``: ``20 * log10(S / ref)``. Zeros in the output correspond to positions where ``S == ref``, by default 1.0 amin : float, optional Minimum threshold for ``S`` and ``ref``, by default 1e-5 top_db : float, optional Threshold the output at ``top_db`` below the peak: ``max(10 * log10(S/ref)) - top_db``, by default -80.0 Returns ------- torch.Tensor Log-magnitude spectrogram rTg$@)rvN)rr#log10powclampr!maximumr;)r.rrr rlog_specr1r1r2 log_magnitudeszAudioSignal.log_magnitudecCr)aHComputes and returns the phase of the STFT. This value can also be set to some tensor. When set, ``self.stft_data`` is manipulated so that its phase matches what this is set to, we original magnitudeith th. Returns ------- torch.Tensor Phase of STFT. Examples -------- >>> signal = AudioSignal(torch.randn(44100), 44100) >>> phase = signal.phase # Computes stft if not computed >>> phase[phase < phase.mean()] = 0 >>> signal.phase = phase >>> signal.istft() N)r)rr#angler6r1r1r2rrzAudioSignal.phasecCs|jtd||_dSr)rr#rr)rr1r1r2rrcCs |}|jt|7_|Srrr'r _get_valuer.other new_signalr1r1r2__add__zAudioSignal.__add__cCs|jt|7_|Srr'rr)r.r+r1r1r2__iadd__zAudioSignal.__iadd__cCs||Srr1r0r1r1r2__radd__zAudioSignal.__radd__cCs |}|jt|8_|Srr(r*r1r1r2__sub__r.zAudioSignal.__sub__cCs|jt|8_|Srr/r0r1r1r2__isub__r2zAudioSignal.__isub__cCs |}|jt|9_|Srr(r*r1r1r2__mul__r.zAudioSignal.__mul__cCs|jt|9_|Srr/r0r1r1r2__imul__ r2zAudioSignal.__imul__cCs||Srr1r0r1r1r2__rmul__ r4zAudioSignal.__rmul__c CsX|jr|jdnd}|d|j|jr|jnd|j|jr|jnd|jj|j|jd}|S)Nz0.3fz [unknown]z secondsz path unknown)rrLpathrrKzaudio_data.shaperr) rrLr&rrKr'rRrr)r.durr9r1r1r2_infos zAudioSignal._infocCs<|}d}|D]\}}d|d|d}||7}q |S)aProduces a markdown representation of AudioSignal, in a markdown table. Returns ------- str Markdown representation of AudioSignal. Examples -------- >>> signal = AudioSignal(torch.randn(44100), 44100) >>> print(signal.markdown()) | Key | Value |---|--- | duration | 1.000 seconds | | batch_size | 1 | | path | path unknown | | sample_rate | 44100 | | num_channels | 1 | | audio_data.shape | torch.Size([1, 1, 44100]) | | stft_params | STFTParams(window_length=2048, hop_length=512, window_type='sqrt_hann', match_stride=False) | | device | cpu | z| Key | Value |---|--- z| z | z | r<items)r.r9FORMATkvrowr1r1r2markdown s  zAudioSignal.markdowncCs6|}d}|D]\}}||d|d7}q |S)N:  r=)r.r9descr@rAr1r1r2__str__?s zAudioSignal.__str__cCsfddlm}|}||jjd}|jddd|jddd|D] \}}||t|q$|S) Nr)Table)titleKeygreen)styleValuecyan) rich.tablerIr< __class____name__ add_columnr>add_rowr)r.rIr9tabler@rAr1r1r2__rich__Gs zAudioSignal.__rich__cCslt|jD],\}}t|r3tj||j|dds3||j|}td|d|dSqdS)Nr)atolzMax abs error for rEFT) list__dict__r>r#r$allcloser\r;print)r.r+r@rA max_errorr1r1r2__eq__Us zAudioSignal.__eq__cCst|r!|jdkr!|dur!|jdksJ|j}|j}|j}n1t|t t t t t fs5t|rR|jdkrR|j|}|jdurD|j|nd}|jdurP|j|nd}d}t|||j|jd}||_||_||_|S)NrTrr)r#r$ritemrLr'rr)rboolrMrXslicetuplerrrrr()r.rr'rr)r(rr1r1r2 __getitem___s$   zAudioSignal.__getitem__cCst|t|s||j|<dSt|r3|jdkr3|dur3|jdks%J|j|_|j|_|j |_ dSt|t t t t tfsGt|ry|jdkr{|jdurW|jdurW|j|j|<|jdurg|jdurg|j|j|<|j durw|j durw|j |j |<dSdSdS)NrTr)rrr'r#r$rr^rLrr)r_rMrXr`ra)r.rrr1r1r2 __setitem__zs,      zAudioSignal.__setitem__cCs ||k Srr1r0r1r1r2__ne__s zAudioSignal.__ne__)NNrNN)NNN)NrDN)rr)rrP)FFFr)r)rr)rN)rrN)rN)rrr)rrr)YrR __module__ __qualname____doc__typingUnionr#Tensorrrr!r"rMrrr3propertyr7 classmethodrandom RandomStaterCrJrNrcrXr_rr*r+rrrrrrrrgrrrrrurrrwrr'settersamplesr)rLrjrrRrrrK staticmethod functools lru_cacherrrrrrrr rrr&rr-r1r3r5r6r7r8r9r<rCrHrVr]rbrcrdr1r1r1r2r5s > /    /  < % 5 a  9 ()                      $ ] T" &         r)%rrrrrr rrhr collectionsrrrrr!rr#rDrdisplayrdspreffectsrr ffmpegr rHr playbackr whisperr r__new__ __defaults__rr1r1r1r2sN