o
    pi6                     @  s  d dl mZ d dlZd dlmZ d dlZd dlZer&d dlmZ ddl	m
Z
 G dd dZe Ze dSddZe dTdUddZe 	dTdVddZe dTdUddZe dWd!d"Ze dXd#d$Ze dYd%d&Ze dZd)d*Ze 	dTdUd+d,Ze 	dTd[d/d0Ze 	dTd\d2d3Ze 	d]dUd6d7Ze dTdUd8d9Ze dTdUd:d;Ze 	d^dUd=d>Ze 	dTd_d@dAZe 	d`dUdCdDZe dTdUdEdFZe dTdUdGdHZ e dTdUdIdJZ!e dTdUdKdLZ"		dTdadQdRZ#dS )b    )annotationsN)TYPE_CHECKING)Tensor   )_WindowLiteralc                   @  s&   e Zd Zdd ZdddZdd ZdS )	WindowFunctionRegisterc                 C  s
   i | _ d S N_functions_dictself r   e/home/app/PaddleOCR-VL/.venv_paddleocr/lib/python3.10/site-packages/paddle/audio/functional/window.py__init__      
zWindowFunctionRegister.__init__Nc                   s    fdd}|S )Nc                   s   | j }|  j|< | S r   )__name__r
   )funcnamer   r   r   add_subfunction!   s   
z8WindowFunctionRegister.register.<locals>.add_subfunctionr   )r   r   r   r   r   r   register    s   zWindowFunctionRegister.registerc                 C  s
   | j | S r   r	   )r   r   r   r   r   get(   r   zWindowFunctionRegister.getr   )r   
__module____qualname__r   r   r   r   r   r   r   r      s    
r   xlist[Tensor]	data_typestrreturnr   c                 C  sT   g }| D ] }t |rt|ts|t|g| q|t|| qt|S r   )npZisscalar
isinstancer   appendpaddle	to_tensorconcat)r   r   ltr   r   r   _cat/   s   
r&   Tfloat64Mintsymbooldtypec                 C  s   t | rtj| f|dS t| |\} }tjd| |d}tj| |d} tt|| d d d| | d  dd| | d   }t||S )zm
    Computes the Bartlett window.
    This function is consistent with scipy.signal.windows.bartlett().
    r,   r             @)	_len_guardsr!   ones_extendaranger"   whereZ
less_equal	_truncater(   r*   r,   needs_truncnwr   r   r   	_bartlett:   s   
r:   betafloatc                 C  s   t | rtj| f|dS t| |\} }tj||d}tjd| |d}tj| |d} | d d }t|td|| | d   t| }t||S )zcCompute the Kaiser window.
    This function is consistent with scipy.signal.windows.kaiser().
    r-   r   r.   r/   )	r0   r!   r1   r2   r"   r3   Zi0sqrtr5   )r(   r;   r*   r,   r7   r8   alphar9   r   r   r   _kaiserO   s   
r?   c                 C  s"   t jg d|d}t| |||dS )zYNuttall window.
    This function is consistent with scipy.signal.windows.nuttall().
    )gzD?g;%N?g1|?gC ˅?r-   )ar*   r,   )r!   r"   _general_cosine)r(   r*   r,   r@   r   r   r   _nuttallf   s   rB   Tensor | floatc                 C  sD   t | trt| t| d d  S t| tt| d  S )Nr   r.   )r   r<   mathlogr=   r!   Zsquare)r   r   r   r   _acoshq   s   
rF   c                 C  s   |s| d dfS | dfS )z:Extend window by 1 sample if needed for DFT-even symmetry.r.   TFr   )r(   r*   r   r   r   r2   x   s   r2   c                 C  s$   t | | ks
| dk rtd| dkS )z)Handle small or incorrect window lengths.r   z.Window length M must be a non-negative integerr.   )r)   
ValueError)r(   r   r   r   r0      s   r0   r9   neededc                 C  s   |r| dd S | S )z<Truncate window by 1 sample if needed for DFT-even symmetry.Nr   )r9   rH   r   r   r   r5      s   r5   c                 C  sl   t | rtj| f|dS t| |\} }tjd| |d| d d  }tdt|| d|   }t||S )zCompute a window with a generalized Gaussian shape.
    This function is consistent with scipy.signal.windows.general_gaussian().
    r-   r         ?r/   g      r   )r0   r!   r1   r2   r3   expabsr5   )r(   psigr*   r,   r7   r8   r9   r   r   r   _general_gaussian   s    
rO   r@   list[float]c                 C  s   t | rtj| f|dS t| |\} }tjtj tj| |d}tj| f|d}tt	|D ]}||| t
||  7 }q-t||S )zCompute a generic weighted sum of cosine terms window.
    This function is consistent with scipy.signal.windows.general_cosine().
    r-   )r0   r!   r1   r2   linspacerD   piZzerosrangelencosr5   )r(   r@   r*   r,   r7   facr9   kr   r   r   rA      s   
rA   r>   c                 C  s   t | |d| g||dS )zvCompute a generalized Hamming window.
    This function is consistent with scipy.signal.windows.general_hamming()
    rJ   r-   rA   )r(   r>   r*   r,   r   r   r   _general_hamming   s   rY         c              	     s  t rtjf|dS t|\}d|d  }t|tj }|d |d |d d   }	tjd||dtj|d f|d t	}
d|
ddd< d|
ddd<  }t
tD ]u}|
| td|| |	 |d d d     }|d	krdtd|| ||d d    }n<|td krdtd|| |d|    }n"dtd|| |d|    td|| ||d d    }||  |< q] fd
d}|tjd	|d}|rd|d d  }||9 }| }t||S )zCompute a Taylor window.
    The Taylor window taper function approximates the Dolph-Chebyshev window's
    constant sidelobe level for a parameterized number of near-in sidelobes.
    r-   
      r         ?r.   NrI   r   c                   sD   ddt  dt dtj d | d  d     S )Nr.   r   r   r/   r^   )r!   matmulZ	unsqueezerU   rD   rR   )r8   ZFmr(   mar   r   W   s   ,z_taylor.<locals>.WrJ   )r0   r!   r1   r2   rF   rD   rR   r3   emptyZ
empty_likerS   rT   prodZsqueezer5   )r(   ZnbarZsllZnormr*   r,   r7   BAs2Zsignsm2minumberdenomrb   r9   scaler   r`   r   _taylor   sD   

"($ 
rm   c                 C     t | d||dS )zCompute a Hamming window.
    The Hamming window is a taper formed by using a raised cosine with
    non-zero endpoints, optimized to minimize the nearest side lobe.
    gHzG?r-   rY   r(   r*   r,   r   r   r   _hamming      rq   c                 C  rn   )zCompute a Hann window.
    The Hann window is a taper formed by using a raised cosine or sine-squared
    with ends that touch zero.
    r^   r-   ro   rp   r   r   r   _hann  rr   rs   r^   c              	   C  s<  t | rtj| f|dS |dkrtj| f|dS |dkr"t| |dS t| |\} }tjd| |d}t|| d  d }|d|d  }||d | | d  }|| | d d }	ddttj	d	d| | | d      }
tj|j
|d}ddttj	d
| d d|	 | | d      }t|
||g}t||S )z[Compute a Tukey window.
    The Tukey window is also known as a tapered cosine window.
    r-   r   rJ   )r*   r.   r/   Nr^   rI   g       )r0   r!   r1   rs   r2   r3   r)   rU   rD   rR   shaper#   r5   )r(   r>   r*   r,   r7   r8   widthZn1Zn2Zn3Zw1Zw2Zw3r9   r   r   r   _tukey
  s*   ,*
rv   stdc                 C  sl   t | rtj| f|dS t| |\} }tjd| |d| d d  }d| | }t|d  | }t||S )ztCompute a Gaussian window.
    The Gaussian widows has a Gaussian shape defined by the standard deviation(std).
    r-   r   rJ   r/   r   )r0   r!   r1   r2   r3   rK   r5   )r(   rw   r*   r,   r7   r8   Zsig2r9   r   r   r   	_gaussian,  s   
rx   rJ   c                 C  s   |r
|dur
t dt| rtj| f|dS t| |\} }|du r'| d d }tjd| |d}tt||  | }t||S )z+Compute an exponential (or Poisson) window.Nz"If sym==True, center must be None.r-   r.   r   r   )	rG   r0   r!   r1   r2   r3   rK   rL   r5   )r(   centertaur*   r,   r7   r8   r9   r   r   r   _exponential>  s   
r{   c                 C  s   t | rtj| f|dS t| |\} }tjd| d d d |d}| d dkr<d| d |  }t||ddd g}nd| | d  }t||ddd g}t||S )	zCompute a triangular window.r-   r.   r   r   rJ   NrI   )r0   r!   r1   r2   r3   r#   r5   r6   r   r   r   _triangR  s   
r}   c                 C  s   t | rtj| f|dS t| |\} }ttjdd| |ddd }d| ttj|  dtj t	tj|   }t
d|dg|}t||S )z^Compute a Bohman window.
    The Bohman window is the autocorrelation of a cosine window.
    r-   rI   r.   rJ   r   )r0   r!   r1   r2   rL   rQ   rU   rD   rR   sinr&   r5   )r(   r*   r,   r7   rV   r9   r   r   r   _bohmand  s    "
r   c                 C  s   t | g d||dS )a  Compute a Blackman window.
    The Blackman window is a taper formed by using the first three terms of
    a summation of cosines. It was designed to have close to the minimal
    leakage possible.  It is close to optimal, only slightly worse than a
    Kaiser window.
    )gzG?r^   g{Gz?r-   rX   rp   r   r   r   	_blackmanv  s   r   c                 C  sT   t | rtj| f|dS t| |\} }ttj|  tjd| |dd  }t||S )z,Compute a window with a simple cosine shape.r-   r   r^   )	r0   r!   r1   r2   r~   rD   rR   r3   r5   )r(   r*   r,   r7   r9   r   r   r   _cosine  s
   $
r   window-_WindowLiteral | tuple[_WindowLiteral, float]
win_lengthfftbinsc              
   C  s   | }d}t | tr| d }t| dkr| dd }nt | tr/| dv r,td|  d | }n	tt|  dz	td	| }W n tyR } ztd
|d}~ww |g|R }	d|i}
||	d|i|
S )a	  Return a window of a given length and type.

    Args:
        window (Union[str, Tuple[str, float]]): The window function applied to the signal before the Fourier transform. Supported window functions: 'hamming', 'hann', 'gaussian', 'general_gaussian', 'exponential', 'triang', 'bohman', 'blackman', 'cosine', 'tukey', 'taylor', 'bartlett', 'kaiser', 'nuttall'.
        win_length (int): Number of samples.
        fftbins (bool, optional): If True, create a "periodic" window. Otherwise, create a "symmetric" window, for use in filter design. Defaults to True.
        dtype (str, optional): The data type of the return window. Defaults to 'float64'.

    Returns:
        Tensor: The window represented as a tensor.

    Examples:
        .. code-block:: python

            >>> import paddle

            >>> n_fft = 512
            >>> cosine_window = paddle.audio.functional.get_window('cosine', n_fft)

            >>> std = 7
            >>> gaussian_window = paddle.audio.functional.get_window(('gaussian', std), n_fft)
    r   r   r.   N)ZgaussianZexponentialZkaiserzThe 'z6' window needs one or more parameters -- pass a tuple.z! as window type is not supported._zUnknown window type.r*   r,   )	r   tuplerT   r   rG   typewindow_function_registerr   KeyError)r   r   r   r,   r*   argsZwinstrZwinfunceparamskwargsr   r   r   
get_window  s.   



r   )r   r   r   r   r   r   )Tr'   )r(   r)   r*   r+   r,   r   r   r   )
r(   r)   r;   r<   r*   r+   r,   r   r   r   )r   rC   r   r   )r(   r)   r*   r+   r   r+   )r(   r)   r   r+   )r9   r   rH   r+   r   r   )
r(   r)   r@   rP   r*   r+   r,   r   r   r   )
r(   r)   r>   r<   r*   r+   r,   r   r   r   )rZ   r[   TTr'   )r^   Tr'   )
r(   r)   rw   r<   r*   r+   r,   r   r   r   )NrJ   Tr'   )
r   r   r   r)   r   r+   r,   r   r   r   )$
__future__r   rD   typingr   numpyr   r!   r   Zfeatures.layersr   r   r   r   r&   r:   r?   rB   rF   r2   r0   r5   rO   rA   rY   rm   rq   rs   rv   rx   r{   r}   r   r   r   r   r   r   r   r   <module>   s~   

	8!
