




'''simple docstring'''


from math import ceil
from typing import List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import BatchFeature, SequenceFeatureExtractor
from ...utils import TensorType, logging


_lowercase  =			logging.get_logger(__name__)
class 						a_				(			UpperCAmelCase__						):
	lowercase_       :     Dict			  =      ['''audio_values''', '''audio_mask''']




	def __init__(       self     :  Optional[int]       ,		__lowerCAmelCase     :  List[Any]=2_0_4_8       ,		__lowerCAmelCase     :  List[Any]=1       ,		__lowerCAmelCase     :  List[Any]=[1_6, 1_6]       ,		__lowerCAmelCase     :  int=1_2_8       ,		__lowerCAmelCase     :  Union[str, Any]=4_4_1_0_0       ,		__lowerCAmelCase     :  Union[str, Any]=8_6       ,		__lowerCAmelCase     :  List[Any]=2_0_4_8       ,		__lowerCAmelCase     :  str=0.0       ,		**__lowerCAmelCase     :  List[Any]       ,		):
							super().__init__(
							    feature_size=__lowerCAmelCase       ,		sampling_rate=__lowerCAmelCase       ,		padding_value=__lowerCAmelCase       ,		**__lowerCAmelCase       ,		)

							__snake_case						 =   spectrogram_length
							__snake_case						 =   num_channels
							__snake_case						 =   patch_size
							__snake_case						 =   feature_size // self.patch_size[1]
							__snake_case						 =   n_fft
							__snake_case						 =   sampling_rate // hop_length_to_sampling_rate
							__snake_case						 =   sampling_rate
							__snake_case						 =   padding_value
							__snake_case						 =   mel_filter_bank(
							    num_frequency_bins=1 + n_fft // 2       ,		num_mel_filters=__lowerCAmelCase       ,		min_frequency=0.0       ,		max_frequency=22050.0       ,		sampling_rate=__lowerCAmelCase       ,		norm='slaney'       ,		mel_scale='slaney'       ,		).T




	def   lowercase__   (       self     :  Dict       ,		__lowerCAmelCase     :  np.array      ):
							__snake_case						 =   spectrogram(
							    __lowerCAmelCase       ,		window_function(self.n_fft       ,		'hann'      )       ,		frame_length=self.n_fft       ,		hop_length=self.hop_length       ,		power=2.0       ,		mel_filters=self.mel_filters.T       ,		log_mel='dB'       ,		db_range=80.0       ,		)
							__snake_case						 =   log_spec[:, :-1]
							__snake_case						 =   log_spec - 20.0
							__snake_case						 =   np.clip(log_spec / 40.0       ,		-2.0       ,		0.0      ) + 1.0
							return log_spec




	def __call__(       self     :  List[str]       ,		__lowerCAmelCase     :  Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]       ,		__lowerCAmelCase     :  Optional[Union[str, TensorType]] = None       ,		__lowerCAmelCase     :  Optional[bool] = True       ,		__lowerCAmelCase     :  Optional[int] = None       ,		__lowerCAmelCase     :  bool = False       ,		__lowerCAmelCase     :  bool = False       ,		**__lowerCAmelCase     :  Tuple       ,		):

							if sampling_rate is not None:
													if sampling_rate != self.sampling_rate:
																			raise ValueError(
																			    'This feature extractor is set to support sampling rate'
																			    F' of {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled'
																			    F' with {self.sampling_rate} and not {sampling_rate}.'      )
							else:
													logger.warning(
													    'It is strongly recommended to pass the `sampling_rate` argument to this function. '
													    'Failing to do so can result in silent errors that might be hard to debug.'      )

							__snake_case						 =   isinstance(__lowerCAmelCase       ,		np.ndarray      ) and len(raw_speech.shape      ) > 1
							if is_batched_numpy and len(raw_speech.shape      ) > 2:
													raise ValueError(F'Only mono-channel audio is supported for input to {self}'      )
							__snake_case						 =   is_batched_numpy or (
							    isinstance(__lowerCAmelCase       ,		(list, tuple)      ) and (isinstance(raw_speech[0]       ,		(np.ndarray, tuple, list)      ))
							)
							if is_batched:
													__snake_case						 =   [np.asarray([speech]       ,		dtype=np.floataa      ).T for speech in raw_speech]
							elif not is_batched and not isinstance(__lowerCAmelCase       ,		np.ndarray      ):
													__snake_case						 =   np.asarray(__lowerCAmelCase       ,		dtype=np.floataa      )
							elif isinstance(__lowerCAmelCase       ,		np.ndarray      ) and raw_speech.dtype is np.dtype(np.floataa      ):
													__snake_case						 =   raw_speech.astype(np.floataa      )
							# always return batch
							if not is_batched:
													__snake_case						 =   [np.asarray([raw_speech]      ).T]

							# Convert audio signals to log mel spectrograms, truncate by time axis
							__snake_case						 =   [
							    self._np_extract_fbank_features(waveform.squeeze()      ).T[: self.spectrogram_length] for waveform in raw_speech
							]
							if isinstance(audio_features[0]       ,		__lowerCAmelCase      ):
													__snake_case						 =   [np.asarray(__lowerCAmelCase       ,		dtype=np.floataa      ) for feature in audio_features]

							# Create audio attention mask
							__snake_case						 =   max(
							    [ceil(feature.shape[0] / self.patch_size[0]      ) * self.freq_len for feature in audio_features]      )  # The maximum number of audio patches in a batch
							if return_attention_mask:
													__snake_case						 =   [
													    (ceil(feature.shape[0] / self.patch_size[0]      ) * self.freq_len) * [1]
													    + (max_patch_len - ceil(feature.shape[0] / self.patch_size[0]      ) * self.freq_len) * [0]
													    for feature in audio_features
													]
													__snake_case						 =   np.array(__lowerCAmelCase      ).astype(np.floataa      )

							# convert into correct format for padding
							__snake_case						 =   max_patch_len // self.freq_len * self.patch_size[0]  # The maximum audio size in a batch
							__snake_case						 =   np.ones([len(__lowerCAmelCase      ), 1, max_time_len, self.feature_size]      ).astype(np.floataa      )
							__snake_case						 =   padded_audio_features * self.padding_value
							for i in range(len(__lowerCAmelCase      )      ):
													__snake_case						 =   audio_features[i]
													__snake_case						 =   feature

							# return as BatchFeature
							if return_attention_mask:
													__snake_case						 =   {'audio_values': padded_audio_features, 'audio_mask': audio_mask}
							else:
													__snake_case						 =   {'audio_values': padded_audio_features}

							__snake_case						 =   BatchFeature(data=__lowerCAmelCase       ,		tensor_type=__lowerCAmelCase      )
							return encoded_inputs







'''simple docstring'''


import warnings

from ...utils import logging
from .image_processing_videomae import VideoMAEImageProcessor


_lowercase  =			logging.get_logger(__name__)
class 						a_				(			UpperCAmelCase__						):




	def __init__(       self     :  Tuple       ,		*__lowerCAmelCase     :  List[str]       ,		**__lowerCAmelCase     :  List[str]      ):
							warnings.warn(
							    'The class VideoMAEFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
							    ' Please use VideoMAEImageProcessor instead.'       ,		__lowerCAmelCase       ,		)
							super().__init__(*__lowerCAmelCase       ,		**__lowerCAmelCase      )

