diff --git a/PaddleAudio/paddleaudio/core/windowing.py b/PaddleAudio/paddleaudio/core/windowing.py
index 62ffdc320e4b5903a01d10c427a3034fc296d5ae..b325c3209bdb5fcf4c8d6dde43a10d63d1f50e2c 100644
--- a/PaddleAudio/paddleaudio/core/windowing.py
+++ b/PaddleAudio/paddleaudio/core/windowing.py
@@ -30,7 +30,6 @@ __all__ = [
     'tukey',
     'taylor',
 ]
-math.pi = 3.141592653589793
 
 
 def _cat(a: List[Tensor], data_type: str) -> Tensor:
@@ -68,30 +67,42 @@ def _truncate(w: Tensor, needed: bool) -> Tensor:
         return w
 
 
-def general_gaussian(M: int, p, sig, sym: bool = True) -> Tensor:
+def general_gaussian(M: int,
+                     p,
+                     sig,
+                     sym: bool = True,
+                     dtype: str = 'float64') -> Tensor:
     """Compute a window with a generalized Gaussian shape.
 
     This function is consistent with scipy.signal.windows.general_gaussian().
     """
     if _len_guards(M):
-        return paddle.ones((M, ), dtype='float32')
+        return paddle.ones((M, ), dtype=dtype)
     M, needs_trunc = _extend(M, sym)
 
-    n = paddle.arange(0, M) - (M - 1.0) / 2.0
+    n = paddle.arange(0, M, dtype=dtype) - (M - 1.0) / 2.0
     w = paddle.exp(-0.5 * paddle.abs(n / sig)**(2 * p))
 
     return _truncate(w, needs_trunc)
 
 
-def general_hamming(M: int, alpha: float, sym: bool = True) -> Tensor:
+def general_hamming(M: int,
+                    alpha: float,
+                    sym: bool = True,
+                    dtype: str = 'float64') -> Tensor:
     """Compute a generalized Hamming window.
 
     This function is consistent with scipy.signal.windows.general_hamming()
     """
-    return general_cosine(M, [alpha, 1. - alpha], sym)
+    return general_cosine(M, [alpha, 1. - alpha], sym, dtype=dtype)
 
 
-def taylor(M: int, nbar=4, sll=30, norm=True, sym: bool = True) -> Tensor:
+def taylor(M: int,
+           nbar=4,
+           sll=30,
+           norm=True,
+           sym: bool = True,
+           dtype: str = 'float64') -> Tensor:
     """Compute 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.
@@ -100,13 +111,14 @@ def taylor(M: int, nbar=4, sll=30, norm=True, sym: bool = True) -> Tensor:
         nbar, sil, norm: the window-specific parameter.
         sym(bool)：whether to return symmetric window.
             The default value is True
+        dtype(str): the datatype of returned tensor.
     Returns:
         Tensor: the window tensor
     Notes:
         This function is consistent with scipy.signal.windows.taylor().
     """
     if _len_guards(M):
-        return paddle.ones((M, ), dtype='float32')
+        return paddle.ones((M, ), dtype=dtype)
     M, needs_trunc = _extend(M, sym)
     # Original text uses a negative sidelobe level parameter and then negates
     # it in the calculation of B. To keep consistent with other methods we
@@ -114,9 +126,9 @@ def taylor(M: int, nbar=4, sll=30, norm=True, sym: bool = True) -> Tensor:
     B = 10**(sll / 20)
     A = _acosh(B) / math.pi
     s2 = nbar**2 / (A**2 + (nbar - 0.5)**2)
-    ma = paddle.arange(1, nbar, dtype='float32')
+    ma = paddle.arange(1, nbar, dtype=dtype)
 
-    Fm = paddle.empty((nbar - 1, ), dtype='float32')
+    Fm = paddle.empty((nbar - 1, ), dtype=dtype)
     signs = paddle.empty_like(ma)
     signs[::2] = 1
     signs[1::2] = -1
@@ -139,7 +151,7 @@ def taylor(M: int, nbar=4, sll=30, norm=True, sym: bool = True) -> Tensor:
             Fm.unsqueeze(0),
             paddle.cos(2 * math.pi * ma.unsqueeze(1) * (n - M / 2. + 0.5) / M))
 
-    w = W(paddle.arange(0, M, dtype='float32'))
+    w = W(paddle.arange(0, M, dtype=dtype))
 
     # normalize (Note that this is not described in the original text [1])
     if norm:
@@ -149,22 +161,25 @@ def taylor(M: int, nbar=4, sll=30, norm=True, sym: bool = True) -> Tensor:
     return _truncate(w, needs_trunc)
 
 
-def general_cosine(M: int, a: float, sym: bool = True) -> Tensor:
+def general_cosine(M: int,
+                   a: float,
+                   sym: bool = True,
+                   dtype: str = 'float64') -> Tensor:
     """Compute a generic weighted sum of cosine terms window.
 
     This function is consistent with scipy.signal.windows.general_cosine().
     """
     if _len_guards(M):
-        return paddle.ones((M, ), dtype='float32')
+        return paddle.ones((M, ), dtype=dtype)
     M, needs_trunc = _extend(M, sym)
-    fac = paddle.linspace(-math.pi, math.pi, M)
-    w = paddle.zeros((M, ), dtype='float32')
+    fac = paddle.linspace(-math.pi, math.pi, M, dtype=dtype)
+    w = paddle.zeros((M, ), dtype=dtype)
     for k in range(len(a)):
         w += a[k] * paddle.cos(k * fac)
     return _truncate(w, needs_trunc)
 
 
-def hamming(M: int, sym: bool = True) -> Tensor:
+def hamming(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
     """Compute 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.
@@ -172,15 +187,16 @@ def hamming(M: int, sym: bool = True) -> Tensor:
         M(int): window size
         sym(bool)：whether to return symmetric window.
             The default value is True
+        dtype(str): the datatype of returned tensor.
     Returns:
         Tensor: the window tensor
     Notes:
         This function is consistent with scipy.signal.windows.hamming().
     """
-    return general_hamming(M, 0.54, sym)
+    return general_hamming(M, 0.54, sym, dtype=dtype)
 
 
-def hann(M: int, sym: bool = True) -> Tensor:
+def hann(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
     """Compute a Hann window.
     The Hann window is a taper formed by using a raised cosine or sine-squared
     with ends that touch zero.
@@ -188,44 +204,49 @@ def hann(M: int, sym: bool = True) -> Tensor:
         M(int): window size
         sym(bool)：whether to return symmetric window.
             The default value is True
+        dtype(str): the datatype of returned tensor.
     Returns:
         Tensor: the window tensor
     Notes:
         This function is consistent with scipy.signal.windows.hann().
     """
-    return general_hamming(M, 0.5, sym)
+    return general_hamming(M, 0.5, sym, dtype=dtype)
 
 
-def tukey(M: int, alpha=0.5, sym: bool = True) -> Tensor:
+def tukey(M: int,
+          alpha=0.5,
+          sym: bool = True,
+          dtype: str = 'float64') -> Tensor:
     """Compute a Tukey window.
     The Tukey window is also known as a tapered cosine window.
     Parameters:
         M(int): window size
         sym(bool)：whether to return symmetric window.
             The default value is True
+        dtype(str): the datatype of returned tensor.
     Returns:
         Tensor: the window tensor
     Notes:
         This function is consistent with scipy.signal.windows.tukey().
     """
     if _len_guards(M):
-        return paddle.ones((M, ), dtype='float32')
+        return paddle.ones((M, ), dtype=dtype)
 
     if alpha <= 0:
-        return paddle.ones((M, ), dtype='float32')
+        return paddle.ones((M, ), dtype=dtype)
     elif alpha >= 1.0:
         return hann(M, sym=sym)
 
     M, needs_trunc = _extend(M, sym)
 
-    n = paddle.arange(0, M)
+    n = paddle.arange(0, M, dtype=dtype)
     width = int(alpha * (M - 1) / 2.0)
     n1 = n[0:width + 1]
     n2 = n[width + 1:M - width - 1]
     n3 = n[M - width - 1:]
 
     w1 = 0.5 * (1 + paddle.cos(math.pi * (-1 + 2.0 * n1 / alpha / (M - 1))))
-    w2 = paddle.ones(n2.shape, dtype='float32')
+    w2 = paddle.ones(n2.shape, dtype=dtype)
     w3 = 0.5 * (1 + paddle.cos(math.pi * (-2.0 / alpha + 1 + 2.0 * n3 / alpha /
                                           (M - 1))))
     w = paddle.concat([w1, w2, w3])
@@ -233,7 +254,10 @@ def tukey(M: int, alpha=0.5, sym: bool = True) -> Tensor:
     return _truncate(w, needs_trunc)
 
 
-def kaiser(M: int, beta: float, sym: bool = True) -> Tensor:
+def kaiser(M: int,
+           beta: float,
+           sym: bool = True,
+           dtype: str = 'float64') -> Tensor:
     """Compute a Kaiser window.
     The Kaiser window is a taper formed by using a Bessel function.
     Parameters:
@@ -251,7 +275,10 @@ def kaiser(M: int, beta: float, sym: bool = True) -> Tensor:
     raise NotImplementedError()
 
 
-def gaussian(M: int, std: float, sym: bool = True) -> Tensor:
+def gaussian(M: int,
+             std: float,
+             sym: bool = True,
+             dtype: str = 'float64') -> Tensor:
     """Compute a Gaussian window.
     The Gaussian widows has a Gaussian shape defined by the standard deviation(std).
 
@@ -260,29 +287,35 @@ def gaussian(M: int, std: float, sym: bool = True) -> Tensor:
         std(float): the window-specific parameter.
         sym(bool)：whether to return symmetric window.
             The default value is True
+        dtype(str): the datatype of returned tensor.
     Returns:
         Tensor: the window tensor
     Notes:
         This function is consistent with scipy.signal.windows.gaussian().
     """
     if _len_guards(M):
-        return paddle.ones((M, ), dtype='float32')
+        return paddle.ones((M, ), dtype=dtype)
     M, needs_trunc = _extend(M, sym)
 
-    n = paddle.arange(0, M) - (M - 1.0) / 2.0
+    n = paddle.arange(0, M, dtype=dtype) - (M - 1.0) / 2.0
     sig2 = 2 * std * std
     w = paddle.exp(-n**2 / sig2)
 
     return _truncate(w, needs_trunc)
 
 
-def exponential(M: int, center=None, tau=1., sym: bool = True) -> Tensor:
+def exponential(M: int,
+                center=None,
+                tau=1.,
+                sym: bool = True,
+                dtype: str = 'float64') -> Tensor:
     """Compute an exponential (or Poisson) window.
     Parameters:
         M(int): window size.
         tau(float): the window-specific parameter.
         sym(bool)：whether to return symmetric window.
             The default value is True
+        dtype(str): the datatype of returned tensor.
     Returns:
         Tensor: the window tensor
     Notes:
@@ -291,34 +324,35 @@ def exponential(M: int, center=None, tau=1., sym: bool = True) -> Tensor:
     if sym and center is not None:
         raise ValueError("If sym==True, center must be None.")
     if _len_guards(M):
-        return paddle.ones((M, ), dtype='float32')
+        return paddle.ones((M, ), dtype=dtype)
     M, needs_trunc = _extend(M, sym)
 
     if center is None:
         center = (M - 1) / 2
 
-    n = paddle.arange(0, M)
+    n = paddle.arange(0, M, dtype=dtype)
     w = paddle.exp(-paddle.abs(n - center) / tau)
 
     return _truncate(w, needs_trunc)
 
 
-def triang(M: int, sym: bool = True) -> Tensor:
+def triang(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
     """Compute a triangular window.
     Parameters:
         M(int): window size.
         sym(bool)：whether to return symmetric window.
             The default value is True
+        dtype(str): the datatype of returned tensor.
     Returns:
         Tensor: the window tensor
     Notes:
         This function is consistent with scipy.signal.windows.triang().
     """
     if _len_guards(M):
-        return paddle.ones((M, ), dtype='float32')
+        return paddle.ones((M, ), dtype=dtype)
     M, needs_trunc = _extend(M, sym)
 
-    n = paddle.arange(1, (M + 1) // 2 + 1)
+    n = paddle.arange(1, (M + 1) // 2 + 1, dtype=dtype)
     if M % 2 == 0:
         w = (2 * n - 1.0) / M
         w = paddle.concat([w, w[::-1]])
@@ -329,31 +363,32 @@ def triang(M: int, sym: bool = True) -> Tensor:
     return _truncate(w, needs_trunc)
 
 
-def bohman(M: int, sym: bool = True) -> Tensor:
+def bohman(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
     """Compute a Bohman window.
     The Bohman window is the autocorrelation of a cosine window.
     Parameters:
         M(int): window size.
         sym(bool)：whether to return symmetric window.
             The default value is True
+        dtype(str): the datatype of returned tensor.
     Returns:
         Tensor: the window tensor
     Notes:
         This function is consistent with scipy.signal.windows.bohman().
     """
     if _len_guards(M):
-        return paddle.ones((M, ), dtype='float32')
+        return paddle.ones((M, ), dtype=dtype)
     M, needs_trunc = _extend(M, sym)
 
-    fac = paddle.abs(paddle.linspace(-1, 1, M)[1:-1])
+    fac = paddle.abs(paddle.linspace(-1, 1, M, dtype=dtype)[1:-1])
     w = (1 - fac) * paddle.cos(math.pi * fac) + 1.0 / math.pi * paddle.sin(
         math.pi * fac)
-    w = _cat([0, w, 0], 'float32')
+    w = _cat([0, w, 0], dtype)
 
     return _truncate(w, needs_trunc)
 
 
-def blackman(M: int, sym: bool = True) -> Tensor:
+def blackman(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
     """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
@@ -364,28 +399,30 @@ def blackman(M: int, sym: bool = True) -> Tensor:
         M(int): window size.
         sym(bool)：whether to return symmetric window.
             The default value is True
+        dtype(str): the datatype of returned tensor.
     Returns:
         Tensor: the window tensor
     Notes:
         This function is consistent with scipy.signal.windows.blackman().
     """
-    return general_cosine(M, [0.42, 0.50, 0.08], sym)
+    return general_cosine(M, [0.42, 0.50, 0.08], sym, dtype=dtype)
 
 
-def cosine(M: int, sym: bool = True) -> Tensor:
+def cosine(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
     """Compute a window with a simple cosine shape.
     Parameters:
         M(int): window size.
         sym(bool)：whether to return symmetric window.
             The default value is True
+        dtype(str): the datatype of returned tensor.
     Returns:
         Tensor: the window tensor
     Notes:
         This function is consistent with scipy.signal.windows.cosine().
     """
     if _len_guards(M):
-        return paddle.ones((M, ), dtype='float32')
+        return paddle.ones((M, ), dtype=dtype)
     M, needs_trunc = _extend(M, sym)
-    w = paddle.sin(math.pi / M * (paddle.arange(0, M) + .5))
+    w = paddle.sin(math.pi / M * (paddle.arange(0, M, dtype=dtype) + .5))
 
     return _truncate(w, needs_trunc)
diff --git a/PaddleAudio/paddleaudio/functional.py b/PaddleAudio/paddleaudio/functional.py
index 025e59033dca5d862dfdd689b3494ba1dd032835..32588b5334910a4742ef9961e44d5066a24aa502 100644
--- a/PaddleAudio/paddleaudio/functional.py
+++ b/PaddleAudio/paddleaudio/functional.py
@@ -46,6 +46,8 @@ __all_ = [
     'random_masking',
     'random_cropping',
     'center_padding',
+    'dct_matrx',
+    'mfcc',
 ]
 
 
@@ -210,7 +212,7 @@ def mel_to_hz(mel: Union[float, Tensor],
     logstep = math.log(6.4) / 27.0  # step size for log region
     if isinstance(mel, Tensor):
         target = min_log_hz * paddle.exp(logstep * (mel - min_log_mel))
-        mask = (mel > min_log_mel).astype('float32')
+        mask = (mel > min_log_mel).astype(mel.dtype)
         freqs = target * mask + freqs * (
             1 - mask)  # will replace by masked_fill OP in future
     else:
@@ -223,14 +225,17 @@ def mel_to_hz(mel: Union[float, Tensor],
 def mel_frequencies(n_mels: int = 128,
                     f_min: float = 0.0,
                     f_max: float = 11025.0,
-                    htk: bool = False) -> Tensor:
+                    htk: bool = False,
+                    dtype: str = 'float64') -> Tensor:
     """Compute mel frequencies.
 
     Parameters:
         n_mels(int): number of Mel bins.
         f_min(float): the lower cut-off frequency, below which the filter response is zero.
         f_max(float): the upper cut-off frequency, above which the filter response is zero.
-        htk: whether to use htk formula.
+        htk(bool): whether to use htk formula.
+        dtype(str): the datatype of the return frequencies.
+
     Returns:
         The frequencies represented in Mel-scale
 
@@ -252,17 +257,18 @@ def mel_frequencies(n_mels: int = 128,
     # 'Center freqs' of mel bands - uniformly spaced between limits
     min_mel = hz_to_mel(f_min, htk=htk)
     max_mel = hz_to_mel(f_max, htk=htk)
-    mels = paddle.linspace(min_mel, max_mel, n_mels)
+    mels = paddle.linspace(min_mel, max_mel, n_mels, dtype=dtype)
     freqs = mel_to_hz(mels, htk=htk)
     return freqs
 
 
-def fft_frequencies(sr: int, n_fft: int) -> Tensor:
+def fft_frequencies(sr: int, n_fft: int, dtype: str = 'float64') -> Tensor:
     """Compute fourier frequencies.
 
     Parameters:
         sr(int): the audio sample rate.
-        n_fft(float): he number of fft bins.
+        n_fft(float): the number of fft bins.
+        dtype(str): the datatype of the return frequencies.
     Returns:
         The frequencies represented in hz.
     Notes:
@@ -278,7 +284,7 @@ def fft_frequencies(sr: int, n_fft: int) -> Tensor:
                 [0., 31.25000000, 62.50000000, ...]
 
     """
-    return paddle.linspace(0, float(sr) / 2, int(1 + n_fft // 2))
+    return paddle.linspace(0, float(sr) / 2, int(1 + n_fft // 2), dtype=dtype)
 
 
 def compute_fbank_matrix(sr: int,
@@ -286,7 +292,9 @@ def compute_fbank_matrix(sr: int,
                          n_mels: int = 128,
                          f_min: float = 0.0,
                          f_max: Optional[float] = None,
-                         htk: bool = False) -> Tensor:
+                         htk: bool = False,
+                         norm: Union[str, float] = 'slaney',
+                         dtype: str = 'float64') -> Tensor:
     """Compute fbank matrix.
 
     Parameters:
@@ -297,8 +305,10 @@ def compute_fbank_matrix(sr: int,
         f_max(float): the upper cut-off frequency, above which the filter response is zero.
         htk: whether to use htk formula.
         return_complex(bool): whether to return complex matrix. If True, the matrix will
-        be complex type. Otherwise, the real and image part will be stored in the last
-        axis of returned tensor.
+            be complex type. Otherwise, the real and image part will be stored in the last
+            axis of returned tensor.
+        dtype(str): the datatype of the returned fbank matrix.
+
     Returns:
         The fbank matrix of shape (n_mels, int(1+n_fft//2)).
     Shape:
@@ -322,13 +332,17 @@ def compute_fbank_matrix(sr: int,
         f_max = float(sr) / 2
 
     # Initialize the weights
-    weights = paddle.zeros((n_mels, int(1 + n_fft // 2)), dtype='float32')
+    weights = paddle.zeros((n_mels, int(1 + n_fft // 2)), dtype=dtype)
 
     # Center freqs of each FFT bin
-    fftfreqs = fft_frequencies(sr=sr, n_fft=n_fft)
+    fftfreqs = fft_frequencies(sr=sr, n_fft=n_fft, dtype=dtype)
 
     # 'Center freqs' of mel bands - uniformly spaced between limits
-    mel_f = mel_frequencies(n_mels + 2, f_min=f_min, f_max=f_max, htk=htk)
+    mel_f = mel_frequencies(n_mels + 2,
+                            f_min=f_min,
+                            f_max=f_max,
+                            htk=htk,
+                            dtype=dtype)
 
     fdiff = mel_f[1:] - mel_f[:-1]  #np.diff(mel_f)
     ramps = mel_f.unsqueeze(1) - fftfreqs.unsqueeze(0)
@@ -344,13 +358,18 @@ def compute_fbank_matrix(sr: int,
                                     paddle.minimum(lower, upper))
 
     # Slaney-style mel is scaled to be approx constant energy per channel
-    enorm = 2.0 / (mel_f[2:n_mels + 2] - mel_f[:n_mels])
-    weights *= enorm.unsqueeze(1)
+    if norm == 'slaney':
+        enorm = 2.0 / (mel_f[2:n_mels + 2] - mel_f[:n_mels])
+        weights *= enorm.unsqueeze(1)
+    elif isinstance(norm, int) or isinstance(norm, float):
+        weights = paddle.nn.functional.normalize(weights, p=norm, axis=-1)
 
     return weights
 
 
-def dft_matrix(n: int, return_complex: bool = False) -> Tensor:
+def dft_matrix(n: int,
+               return_complex: bool = False,
+               dtype: str = 'float64') -> Tensor:
     """Compute discrete Fourier transform matrix.
 
     Parameters:
@@ -358,6 +377,8 @@ def dft_matrix(n: int, return_complex: bool = False) -> Tensor:
         return_complex(bool): whether to return complex matrix. If True, the matrix will
             be complex type. Otherwise, the real and image part will be stored in the last
             axis of returned tensor.
+        dtype(str): the datatype of the returned dft matrix.
+
     Shape:
         output: [n, n] or [n,n,2]
 
@@ -378,10 +399,16 @@ def dft_matrix(n: int, return_complex: bool = False) -> Tensor:
         >> [512, 512]
 
     """
+    # This is due to a bug in paddle in lacking support for complex128, as of paddle 2.1.0
+    if return_complex and dtype == 'float64':
+        raise ValueError('not implemented')
+
     x, y = paddle.meshgrid(paddle.arange(0, n), paddle.arange(0, n))
-    z = x * y * (-2 * math.pi / n)
+    z = x.astype(dtype) * y.astype(dtype) * paddle.to_tensor(
+        (-2 * math.pi / n), dtype)
     cos = paddle.cos(z)
     sin = paddle.sin(z)
+
     if return_complex:
         return cos + paddle.to_tensor([1j]) * sin
     cos = cos.unsqueeze(-1)
@@ -389,7 +416,9 @@ def dft_matrix(n: int, return_complex: bool = False) -> Tensor:
     return paddle.concat([cos, sin], -1)
 
 
-def idft_matrix(n: int, return_complex: bool = False) -> Tensor:
+def idft_matrix(n: int,
+                return_complex: bool = False,
+                dtype: str = 'float64') -> Tensor:
     """Compute inverse discrete Fourier transform matrix
 
     Parameters:
@@ -397,6 +426,7 @@ def idft_matrix(n: int, return_complex: bool = False) -> Tensor:
         return_complex(bool): whether to return complex matrix. If True, the matrix will
             be complex type. Otherwise, the real and image part will be stored in the last
             axis of returned tensor.
+        dtype(str): the data type of returned idft matrix.
     Returns:
         Complex tensor of shape (n,n) if return_complex=True, and of shape (n,n,2) otherwise.
     Examples:
@@ -414,8 +444,13 @@ def idft_matrix(n: int, return_complex: bool = False) -> Tensor:
 
     """
 
-    x, y = paddle.meshgrid(paddle.arange(0, n), paddle.arange(0, n))
-    z = x * y * (2 * math.pi / n)
+    if return_complex and dtype == 'float64':  # there is a bug in paddle for complex128 datatype
+        raise ValueError('not implemented')
+
+    x, y = paddle.meshgrid(paddle.arange(0, n, dtype=dtype),
+                           paddle.arange(0, n, dtype=dtype))
+    z = x.astype(dtype) * y.astype(dtype) * paddle.to_tensor(
+        (2 * math.pi / n), dtype)
     cos = paddle.cos(z)
     sin = paddle.sin(z)
     if return_complex:
@@ -425,9 +460,54 @@ def idft_matrix(n: int, return_complex: bool = False) -> Tensor:
     return paddle.concat([cos, sin], -1)
 
 
+def dct_matrix(n_mfcc: int,
+               n_mels: int,
+               dct_norm: Optional[str] = 'ortho',
+               dtype: str = 'float64') -> Tensor:
+    """Compute discrete cosine transform (DCT) matrix used in MFCC computation.
+
+    Parameters:
+        n_mfcc(int): the number of coefficients in MFCC.
+        n_mels(int): the number of mel bins in the melspectrogram tranform preceding MFCC.
+        dct_norm(None|str): the normalization of the dct transform. If 'ortho', use the orthogonal normalization.
+            If None, not normalization is applied. Default: 'ortho'.
+        dtype(str): the data type of returned dct matrix.
+
+    Shape:
+        output: [n_mels,n_mfcc]
+
+    Returns:
+        The dct matrix of shape [n_mels,n_mfcc]
+
+    Examples:
+
+        .. code-block:: python
+
+        import paddle
+        import paddleaudio.functional as F
+        m = F.dct_matrix(n_mfcc=20,n_mels=64)
+        print(m.shape)
+        >> [64, 20]
+
+    """
+    # http://en.wikipedia.org/wiki/Discrete_cosine_transform#DCT-II
+    n = paddle.arange(float(n_mels), dtype=dtype)
+    k = paddle.arange(float(n_mfcc), dtype=dtype).unsqueeze(1)
+    dct = paddle.cos(math.pi / float(n_mels) * (n + 0.5) *
+                     k)  # size (n_mfcc, n_mels)
+    if dct_norm is None:
+        dct *= 2.0
+    else:
+        assert dct_norm == "ortho"
+        dct[0] *= 1.0 / math.sqrt(2.0)
+        dct *= math.sqrt(2.0 / float(n_mels))
+    return dct.t()
+
+
 def get_window(window: Union[str, Tuple[str, float]],
                win_length: int,
-               fftbins: bool = True) -> Tensor:
+               fftbins: bool = True,
+               dtype: str = 'float64') -> Tensor:
     """Return a window of a given length and type.
     Parameters:
         window(str|(str,float)): the type of window to create.
@@ -473,7 +553,7 @@ def get_window(window: Union[str, Tuple[str, float]],
 
     params = (win_length, ) + args
     kwargs = {'sym': sym}
-    return winfunc(*params, **kwargs)
+    return winfunc(*params, dtype=dtype, **kwargs)
 
 
 def power_to_db(magnitude: Tensor,
@@ -857,7 +937,8 @@ def stft(x: Tensor,
          window: str = 'hann',
          center: bool = True,
          pad_mode: str = 'reflect',
-         one_sided: bool = True):
+         one_sided: bool = True,
+         dtype: str = 'float64'):
     """Compute short-time Fourier transformation(STFT) of a given signal,
     typically an audio waveform.
     The STFT is implemented with strided 1d convolution. The convluational weights are
@@ -882,6 +963,8 @@ def stft(x: Tensor,
         one_sided(bool): If True, the output spectrum will have n_fft//2+1 frequency components.
             Otherwise, it will return the full spectrum that have n_fft+1 frequency values.
             The default value is True.
+        dtype(str): the datatype used internally for computing fft transform coefficients. 'float64' is
+            recommended for higher numerical accuracy.
     Shape:
         - x: 1-D tensor with shape: (signal_length,) or 2-D tensor with shape (N, signal_length).
         - output: 2-D tensor with shape (N, freq_dim, frame_number,2),
@@ -917,9 +1000,9 @@ def stft(x: Tensor,
     # Set the default hop, if it's not already specified.
     if hop_length is None:
         hop_length = int(win_length // 4)
-    fft_window = get_window(window, win_length, fftbins=True)
+    fft_window = get_window(window, win_length, fftbins=True, dtype=dtype)
     fft_window = center_padding(fft_window, n_fft)
-    dft_mat = dft_matrix(n_fft)
+    dft_mat = dft_matrix(n_fft, dtype=dtype)
     if one_sided:
         out_channels = n_fft // 2 + 1
     else:
@@ -933,7 +1016,9 @@ def stft(x: Tensor,
                                      pad=[n_fft // 2, n_fft // 2],
                                      mode=pad_mode,
                                      data_format="NCL")
-    signal = paddle.nn.functional.conv1d(x, weight, stride=hop_length)
+    signal = paddle.nn.functional.conv1d(x,
+                                         weight.astype('float32'),
+                                         stride=hop_length)
 
     signal = signal.transpose([0, 2, 1])
     signal = signal.reshape(
@@ -949,7 +1034,8 @@ def istft(x: Tensor,
           window: str = 'hann',
           center: bool = True,
           pad_mode: str = 'reflect',
-          signal_length: Optional[int] = None) -> Tensor:
+          signal_length: Optional[int] = None,
+          dtype: str = 'float64') -> Tensor:
     """Compute inverse short-time Fourier transform(ISTFT) of a given spectrum signal x.
     To accurately recover the input signal, the exact value of parameters should match
     those used in stft.
@@ -960,6 +1046,8 @@ def istft(x: Tensor,
             with original signal. If set to None, the length is solely determined by hop_length
             and win_length.
             The default value is None.
+        dtype(str): the datatype used internally for computing fft transform coefficients. 'float64' is
+            recommended for higher numerical accuracy.
     Shape:
         - x: 1-D tensor with shape: (signal_length,) or 2-D tensor with shape (N, signal_length).
         - output: the signal represented as a 2-D tensor with shape (N, single_length)
@@ -1016,11 +1104,11 @@ def istft(x: Tensor,
         f'hop_length must be smaller than win_length, ' +
         f'but {hop_length}>={win_length}')
 
-    fft_window = get_window(window, win_length)
+    fft_window = get_window(window, win_length, dtype=dtype)
     fft_window = 1.0 / fft_window
     fft_window = center_padding(fft_window, n_fft)
     fft_window = fft_window.unsqueeze((1, 2))
-    idft_mat = fft_window * idft_matrix(n_fft) / n_fft
+    idft_mat = fft_window * idft_matrix(n_fft, dtype=dtype) / n_fft
     idft_mat = idft_mat.unsqueeze((0, 1))
 
     #let's do the inverse transformation
@@ -1046,12 +1134,13 @@ def spectrogram(x,
                 window: str = 'hann',
                 center: bool = True,
                 pad_mode: str = 'reflect',
-                power: float = 2.0) -> Tensor:
+                power: float = 2.0,
+                dtype: str = 'float64') -> Tensor:
     """Compute spectrogram of a given signal, typically an audio waveform.
         The spectorgram is defined as the complex norm of the short-time
         Fourier transformation.
 
-        Parameters:
+    Parameters:
             n_fft(int): the number of frequency components of the discrete Fourier transform.
                 The default value is 2048,
             hop_length(int|None): the hop length of the short time FFT. If None, it is set to win_length//4.
@@ -1070,7 +1159,9 @@ def spectrogram(x,
                 The default value is 'reflect'.
             power(float): The power of the complex norm.
                 The default value is 2.0
-        Shape:
+            dtype(str): the datatype used internally for computing fft transform coefficients. 'float64' is
+                recommended for higher numerical accuracy.
+    Shape:
             - x: 1-D tensor with shape: (signal_length,) or 2-D tensor with shape (N, signal_length).
             - output: 2-D tensor with shape (N, n_fft//2+1, frame_number),
             The batch size N is set to 1 if input singal x is 1D tensor.
@@ -1093,7 +1184,8 @@ def spectrogram(x,
                       window=window,
                       center=center,
                       pad_mode=pad_mode,
-                      one_sided=True)
+                      one_sided=True,
+                      dtype=dtype)
     spectrogram = paddle.square(fft_signal).sum(-1)
     if power == 2.0:
         pass
@@ -1114,6 +1206,9 @@ def melspectrogram(x: Tensor,
                    n_mels: int = 128,
                    f_min: float = 0.0,
                    f_max: Optional[float] = None,
+                   htk: bool = True,
+                   norm: Union[str, float] = 'slaney',
+                   dtype: str = 'float64',
                    to_db: bool = False,
                    **kwargs) -> Tensor:
     """Compute the melspectrogram of a given signal, typically an audio waveform.
@@ -1145,12 +1240,15 @@ def melspectrogram(x: Tensor,
             f_min(float): the lower cut-off frequency, below which the filter response is zero. Tips:
                 set f_min to slightly higher than 0.
                 The default value is 0.
-
             f_max(float): the upper cut-off frequency, above which the filter response is zero.
                 If None, it is set to half of the sample rate, i.e., sr//2. Tips: set it a slightly
                 smaller than half of sample rate.
                 The default value is None.
-
+            htk(bool): whether to use HTK formula in computing fbank matrix.
+            norm(str|float): the normalization type in computing fbank matrix.  Slaney-style is used by default.
+                You can specify norm=1.0/2.0 to use customized p-norm normalization.
+            dtype(str): the datatype of fbank matrix used in the transform. Use float64(default) to increase numerical
+                accuracy. Note that the final transform will be conducted in float32 regardless of dtype of fbank matrix.
             to_db(bool): whether to convert the magnitude to db scale.
                 The default value is False.
             kwargs: the key-word arguments that are passed to F.power_to_db if to_db is True
@@ -1164,30 +1262,108 @@ def melspectrogram(x: Tensor,
             1. The melspectrogram function relies on F.spectrogram and F.compute_fbank_matrix.
             2. The melspectrogram function does not convert magnitude to db by default.
 
-    Examples:
+        Examples:
 
-        .. code-block:: python
+            .. code-block:: python
 
-        import paddle
-        import paddleaudio.functional as F
-        x = F.melspectrogram(paddle.randn((8, 16000,)))
-        print(x.shape)
-        >> [8, 128, 32]
+            import paddle
+            import paddleaudio.functional as F
+            x = F.melspectrogram(paddle.randn((8, 16000,)))
+            print(x.shape)
+            >> [8, 128, 32]
 
     """
 
-    x = spectrogram(x, n_fft, hop_length, win_length, window, center, pad_mode,
-                    power)
+    x = spectrogram(x,
+                    n_fft=n_fft,
+                    hop_length=hop_length,
+                    win_length=win_length,
+                    window=window,
+                    center=center,
+                    pad_mode=pad_mode,
+                    power=power,
+                    dtype=dtype)
     if f_max is None:
         f_max = sr // 2
     fbank_matrix = compute_fbank_matrix(sr=sr,
                                         n_fft=n_fft,
                                         n_mels=n_mels,
                                         f_min=f_min,
-                                        f_max=f_max)
+                                        f_max=f_max,
+                                        htk=htk,
+                                        norm=norm,
+                                        dtype=dtype)
     fbank_matrix = fbank_matrix.unsqueeze(0)
-    mel_feature = paddle.matmul(fbank_matrix, x)
+    mel_feature = paddle.matmul(fbank_matrix, x.astype(fbank_matrix.dtype))
     if to_db:
         mel_feature = power_to_db(mel_feature, **kwargs)
 
     return mel_feature
+
+
+def mfcc(x,
+         sr: int = 22050,
+         spect: Optional[Tensor] = None,
+         n_mfcc: int = 20,
+         dct_norm: str = 'ortho',
+         lifter: int = 0,
+         dtype: str = 'float64',
+         **kwargs) -> Tensor:
+    """Compute Mel-frequency cepstral coefficients (MFCCs) give an input waveform.
+
+     Parameters:
+            sr(int): the audio sample rate.
+                The default value is 22050.
+            spect(None|Tensor): the melspectrogram tranform result(in db scale). If None, the melspectrogram will be
+                computed using `MelSpectrogram` functional and further converted to db scale using `F.power_to_db`
+                The default value is None.
+            n_mfcc(int): the number of coefficients.
+                The default value is 20.
+            dct_norm: the normalization type of dct matrix. See `dct_matrix` for more details.
+                The default value is 'ortho'.
+            lifter(int): if lifter > 0, apply liftering(cepstral filtering) to the MFCCs.
+                If lifter = 0, no liftering is applied.
+                Setting lifter >= 2 * n_mfcc emphasizes the higher-order coefficients.
+                As lifter increases, the coefficient weighting becomes approximately linear.
+                The default value is 0.
+            dtype(str): the datatype used internally in computing MFCC.
+
+
+    Examples:
+
+        .. code-block:: python
+
+        import paddle
+        import paddleaudio.functional as F
+        x = paddle.randn((8, 16000))  # the waveform
+        y = F.mfcc(x,
+                sr=16000,
+                n_mfcc=20,
+                n_mels=64,
+                n_fft=512,
+                win_length=512,
+                hop_length=160)
+
+        print(y.shape)
+        >> [8, 20, 101]
+    """
+
+    if spect is None:
+        spect = melspectrogram(x, sr=sr, dtype=dtype,
+                               **kwargs)  #[batch,n_mels,frames]
+        spect = power_to_db(spect)  # default top_db is 80
+
+    n_mels = spect.shape[1]
+    if n_mfcc > n_mels:
+        raise ValueError('Value of n_mfcc cannot be larger than n_mels')
+
+    M = dct_matrix(n_mfcc, n_mels, dct_norm=dct_norm, dtype=dtype)
+    out = M.transpose([1, 0]).unsqueeze_(0) @ spect
+    if lifter > 0:
+        factor = paddle.sin(math.pi *
+                            paddle.arange(1, 1 + n_mfcc, dtype=dtype) / lifter)
+        return out @ factor.unsqueeze([0, 2])
+    elif lifter == 0:
+        return out
+    else:
+        raise ValueError(f"MFCC lifter={lifter} must be a non-negative number")
diff --git a/PaddleAudio/paddleaudio/models/wav2vec2/modeling.py b/PaddleAudio/paddleaudio/models/wav2vec2/modeling.py
index 624672b0a8f6cb6ba6547348db9c702e5f580248..7a75240893b767545bbffe1964212b7e0c26118b 100644
--- a/PaddleAudio/paddleaudio/models/wav2vec2/modeling.py
+++ b/PaddleAudio/paddleaudio/models/wav2vec2/modeling.py
@@ -278,13 +278,14 @@ class Wav2Vec2GroupNormConvLayer(nn.Layer):
             bias_attr=config.conv_bias,
         )
         self.activation = ACT2FN[config.feat_extract_activation]
-        # , affine=True ??
         self.layer_norm = nn.GroupNorm(num_groups=self.out_conv_dim,
                                        num_channels=self.out_conv_dim)
 
     def forward(self, hidden_states):
         hidden_states = self.conv(hidden_states)
-        hidden_states = self.layer_norm(hidden_states)
+        # paddle's groupnorm only supports 4D tensor as of 2.1.1. We need to unsqueeze and squeeze.
+        hidden_states = self.layer_norm(hidden_states.unsqueeze([-1]))
+        hidden_states = hidden_states[:, :, :, 0]
         hidden_states = self.activation(hidden_states)
         return hidden_states
 
diff --git a/PaddleAudio/paddleaudio/transforms.py b/PaddleAudio/paddleaudio/transforms.py
index d9065c205438c5dd6ceb5e122f77b57bbdc714fe..8194d29e2ac621ab65868a76f3d8b0a11c2ac351 100644
--- a/PaddleAudio/paddleaudio/transforms.py
+++ b/PaddleAudio/paddleaudio/transforms.py
@@ -12,10 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, List, Optional
+import glob
+import math
+import os
+import random
+from typing import Any, List, Optional, Union
 
 import paddle
 import paddle.nn as nn
+import paddleaudio
 import paddleaudio.functional as F
 from paddle import Tensor
 
@@ -26,12 +31,17 @@ __all__ = [
     'MelSpectrogram',
     'LogMelSpectrogram',
     'Compose',
+    'RandomChoice',
+    'RandomApply',
     'RandomMasking',
     'CenterPadding',
     'RandomCropping',
     'RandomMuLawCodec',
     'MuLawEncoding',
     'MuLawDecoding',
+    'Noisify',
+    'Reverberate',
+    'MFCC',
 ]
 
 
@@ -62,6 +72,8 @@ class STFT(nn.Layer):
         one_sided(bool): If True, the output spectrum will have n_fft//2+1 frequency components.
             Otherwise, it will return the full spectrum that have n_fft+1 frequency values.
             The default value is True.
+        dtype(str): the datatype of used internally in computing STFT transform.
+
     Shape:
         - x: 1-D tensor with shape: (signal_length,) or 2-D tensor with shape (batch, signal_length).
         - output: 2-D tensor with shape [batch_size, freq_dim, frame_number,2],
@@ -90,7 +102,8 @@ class STFT(nn.Layer):
                  window: str = 'hann',
                  center: bool = True,
                  pad_mode: str = 'reflect',
-                 one_sided: bool = True):
+                 one_sided: bool = True,
+                 dtype: str = 'float64'):
 
         super(STFT, self).__init__()
 
@@ -111,10 +124,13 @@ class STFT(nn.Layer):
         # Set the default hop, if it's not already specified.
         if self.hop_length is None:
             self.hop_length = int(self.win_length // 4)
-        fft_window = F.get_window(window, self.win_length, fftbins=True)
+        fft_window = F.get_window(window,
+                                  self.win_length,
+                                  fftbins=True,
+                                  dtype=dtype)
         fft_window = F.center_padding(fft_window, n_fft)
         # DFT & IDFT matrix.
-        dft_mat = F.dft_matrix(n_fft)
+        dft_mat = F.dft_matrix(n_fft, dtype=dtype)
         if one_sided:
             out_channels = n_fft // 2 + 1
         else:
@@ -127,7 +143,7 @@ class STFT(nn.Layer):
         weight = fft_window.unsqueeze([1, 2]) * dft_mat[:, 0:out_channels, :]
         weight = weight.transpose([1, 2, 0])
         weight = weight.reshape([-1, weight.shape[-1]])
-        self.conv.load_dict({'weight': weight.unsqueeze(1)})
+        self.conv.load_dict({'weight': weight.unsqueeze(1).astype('float32')})
         # by default, the STFT is not learnable
         for param in self.parameters():
             param.stop_gradient = True
@@ -170,7 +186,8 @@ class Spectrogram(nn.Layer):
                  window: str = 'hann',
                  center: bool = True,
                  pad_mode: str = 'reflect',
-                 power: float = 2.0):
+                 power: float = 2.0,
+                 dtype: str = 'float64'):
         """Compute spectrogram of a given signal, typically an audio waveform.
         The spectorgram is defined as the complex norm of the short-time
         Fourier transformation.
@@ -194,6 +211,8 @@ class Spectrogram(nn.Layer):
             The default value is 'reflect'.
             power(float): The power of the complex norm.
                 The default value is 2.0
+            dtype(str): the datatype of used internally in computing ISTFT transform.'float64' is
+                recommended for higher numerical accuracy.
 
         Notes:
             The Spectrogram transform relies on STFT transform to compute the spectrogram.
@@ -217,8 +236,13 @@ class Spectrogram(nn.Layer):
         super(Spectrogram, self).__init__()
 
         self.power = power
-        self._stft = STFT(n_fft, hop_length, win_length, window, center,
-                          pad_mode)
+        self._stft = STFT(n_fft=n_fft,
+                          hop_length=hop_length,
+                          win_length=win_length,
+                          window=window,
+                          center=center,
+                          pad_mode=pad_mode,
+                          dtype=dtype)
 
     def __repr__(self, ):
         p_repr = str(self._stft).split('(')[-1].split(')')[0]
@@ -230,6 +254,8 @@ class Spectrogram(nn.Layer):
         spectrogram = paddle.square(fft_signal).sum(-1)
         if self.power == 2.0:
             pass
+        elif self.power == 1.0:
+            spectrogram = paddle.sqrt(spectrogram)
         else:
             spectrogram = spectrogram**(self.power / 2.0)
         return spectrogram
@@ -247,7 +273,10 @@ class MelSpectrogram(nn.Layer):
                  power: float = 2.0,
                  n_mels: int = 128,
                  f_min: float = 0.0,
-                 f_max: Optional[float] = None):
+                 f_max: Optional[float] = None,
+                 htk: bool = False,
+                 norm: Union[str, float] = 'slaney',
+                 dtype: str = 'float64'):
         """Compute the melspectrogram of a given signal, typically an audio waveform.
         The melspectrogram is also known as filterbank or fbank feature in audio community.
         It is computed by multiplying spectrogram with Mel filter bank matrix.
@@ -271,13 +300,16 @@ class MelSpectrogram(nn.Layer):
             pad_mode(str): the mode to pad the signal if necessary. The supported modes are 'reflect'
                 and 'constant'.
                 The default value is 'reflect'.
-            power(float): The power of the complex norm.
+            power(float): the power of the complex norm.
                 The default value is 2.0
             n_mels(int): the mel bins.
             f_min(float): the lower cut-off frequency, below which the filter response is zero.
             f_max(float): the upper cut-off frequency, above which the filter response is zeros.
-
-
+            htk(bool): whether to use HTK formula in computing fbank matrix.
+            norm(str|float): the normalization type in computing fbank matrix.  Slaney-style is used by default.
+                You can specify norm=1.0/2.0 to use customized p-norm normalization.
+            dtype(str): the datatype of fbank matrix used in the transform. Use float64(default) to increase numerical
+                accuracy. Note that the final transform will be conducted in float32 regardless of dtype of fbank matrix.
         Notes:
             The melspectrogram transform relies on Spectrogram transform and F.compute_fbank_matrix.
             By default, the Fourier coefficients are not learnable. To fine-tune the Fourier coefficients,
@@ -298,20 +330,31 @@ class MelSpectrogram(nn.Layer):
         """
         super(MelSpectrogram, self).__init__()
 
-        self._spectrogram = Spectrogram(n_fft, hop_length, win_length, window,
-                                        center, pad_mode, power)
+        self._spectrogram = Spectrogram(n_fft=n_fft,
+                                        hop_length=hop_length,
+                                        win_length=win_length,
+                                        window=window,
+                                        center=center,
+                                        pad_mode=pad_mode,
+                                        power=power,
+                                        dtype=dtype)
         self.n_mels = n_mels
         self.f_min = f_min
         self.f_max = f_max
-
+        self.htk = htk
+        self.norm = norm
         if f_max is None:
             f_max = sr // 2
-        self.fbank_matrix = F.compute_fbank_matrix(sr=sr,
-                                                   n_fft=n_fft,
-                                                   n_mels=n_mels,
-                                                   f_min=f_min,
-                                                   f_max=f_max)
-        self.fbank_matrix = self.fbank_matrix.unsqueeze(0)
+        self.fbank_matrix = F.compute_fbank_matrix(
+            sr=sr,
+            n_fft=n_fft,
+            n_mels=n_mels,
+            f_min=f_min,
+            f_max=f_max,
+            htk=htk,
+            norm=norm,
+            dtype=dtype)  # float64 for better numerical results
+        self.fbank_matrix = self.fbank_matrix.unsqueeze(0).astype('float32')
         self.register_buffer('fbank_matrix', self.fbank_matrix)
 
     def forward(self, x: Tensor) -> Tensor:
@@ -322,7 +365,9 @@ class MelSpectrogram(nn.Layer):
     def __repr__(self):
 
         p_repr = str(self._spectrogram).split('(')[-1].split(')')[0]
-        l_repr = f'n_mels={self.n_mels}, f_min={self.f_min}, f_max={self.f_max}'
+        l_repr = (
+            f'n_mels={self.n_mels}, f_min={self.f_min}, f_max={self.f_max}' +
+            f', htk={self.htk}, norm={self.norm}')
         return (self.__class__.__name__ + '(' + l_repr + ', ' + p_repr + ')')
 
 
@@ -339,9 +384,12 @@ class LogMelSpectrogram(nn.Layer):
                  n_mels: int = 64,
                  f_min: float = 0.0,
                  f_max: Optional[float] = None,
+                 htk: bool = False,
+                 norm: Union[str, float] = 'slaney',
                  ref_value: float = 1.0,
                  amin: float = 1e-10,
-                 top_db: Optional[float] = 80.0):
+                 top_db: Optional[float] = 80.0,
+                 dtype: str = 'float64'):
         """Compute log-mel-spectrogram(also known as LogFBank) feature of a given signal,
         typically an audio waveform.
 
@@ -370,13 +418,17 @@ class LogMelSpectrogram(nn.Layer):
             f_min(float): the lower cut-off frequency, below which the filter response is zero.
             f_max(float): the upper cut-off frequency, above which the filter response is zeros.
             ref_value(float): the reference value. If smaller than 1.0, the db level
-                of the signal will be pulled up accordingly. Otherwise, the db level is pushed down.
-            amin(float): the minimum value of input magnitude, below which the input
+            htk(bool): whether to use HTK formula in computing fbank matrix.
+            norm(str|float): the normalization type in computing fbank matrix. Slaney-style is used by default.
+                You can specify norm=1.0/2.0 to use customized p-norm normalization.
+            dtype(str): the datatype of fbank matrix used in the transform. Use float64 to increase numerical
+                accuracy. Note that the final transform will be conducted in float32 regardless of dtype of fbank matrix.
+            amin(float): the minimum value of input magnitude, below which the input of the signal will be pulled up accordingly.
+                Otherwise, the db level is pushed down.
                 magnitude is clipped(to amin). For numerical stability, set amin to a larger value,
                 e.g., 1e-3.
             top_db(float): the maximum db value of resulting spectrum, above which the
                 spectrum is clipped(to top_db).
-
         Notes:
             The LogMelSpectrogram transform relies on MelSpectrogram transform to compute
             spectrogram in mel-scale, and then use paddleaudio.functional.power_to_db to
@@ -409,7 +461,10 @@ class LogMelSpectrogram(nn.Layer):
                                               power=power,
                                               n_mels=n_mels,
                                               f_min=f_min,
-                                              f_max=f_max)
+                                              f_max=f_max,
+                                              htk=htk,
+                                              norm=norm,
+                                              dtype=dtype)
 
         self.ref_value = ref_value
         self.amin = amin
@@ -451,7 +506,8 @@ class ISTFT(nn.Layer):
         pad_mode(str): the mode to pad the signal if necessary. The supported modes are 'reflect'
             and 'constant'.
             The default value is 'reflect'.
-
+        dtype(str): the datatype of used internally in computing ISTFT transform.'float64' is
+            recommended for higher numerical accuracy.
         signal_length(int): the origin signal length for exactly aligning recovered signal
         with original signal. If set to None, the length is solely determined by hop_length
         and win_length.
@@ -479,7 +535,8 @@ class ISTFT(nn.Layer):
                  win_length: Optional[int] = None,
                  window: str = 'hann',
                  center: bool = True,
-                 pad_mode: str = 'reflect'):
+                 pad_mode: str = 'reflect',
+                 dtype: str = 'float64'):
         super(ISTFT, self).__init__()
 
         assert pad_mode in [
@@ -840,3 +897,297 @@ class RandomMuLawCodec(nn.Layer):
     def __repr__(self, ):
         return (self.__class__.__name__ +
                 f'(min_mu={self.min_mu}, max_mu={self.max_mu})')
+
+
+class Reverberate(nn.Layer):
+    """Apply reverberation to input audio tensor.
+
+    Parameters:
+        rir_source: a callable object that reads impulse response from rir dataset.
+
+    Shapes:
+        - x: 2-D tensor with shape [batch_size, frames]
+        - output: 2-D tensor with shape [batch_size, frames]
+
+    Examples:
+
+        .. code-block:: python
+
+        import paddle
+        import paddleaudio.transforms as T
+        x = paddle.randn((2, 48000))
+        # Define RIR source object that read rir weight from folder.
+        # See the speaker example for how to define RIR source object.
+        reader = RIRSource(<rir_folder>)
+        transform = T.Reverberate(reader)
+        y = transform(x)
+        print(y.shape)
+        >> [2, 48000]
+
+    """
+    def __init__(self, rir_source: Any):
+        super(Reverberate, self).__init__()
+        self.rir_source = rir_source
+
+    def forward(self, x: Tensor) -> Tensor:
+        assert x.ndim == 2, (f'the input tensor must be 2d tensor, ' +
+                             f'but received x.ndim={x.ndim}')
+
+        weight = self.rir_source()  #get next weight
+        pad_len = [
+            weight.shape[-1] // 2 - 1, weight.shape[-1] - weight.shape[-1] // 2
+        ]
+        out = paddle.nn.functional.conv1d(x.unsqueeze(1),
+                                          weight,
+                                          padding=pad_len)
+        return out[:, 0, :]
+
+    def __repr__(self):
+        return (self.__class__.__name__ + f'(rir_source={self.rir_source})')
+
+
+class RandomApply():
+    """Compose a list of transforms and apply them to the input tensor Randomly.
+
+    Parameters:
+        transforms: a list of transforms.
+        p(float): the probability that each transform will be chosen independently.
+        Default: 0.5
+    Examples:
+
+        .. code-block:: python
+
+        import paddle
+        import paddleaudio.transforms as T
+        x = paddle.randn((2, 48000))
+        transform1 = T.Reverberate(<rir_reader>)
+        transform2 = T.Noisify(<noise_reader>)
+        # Apply Reverberation and/or Noisify independently.
+        transform = T.RandomApply([
+            transform1,
+            transform2,
+        ],p=0.3)
+        y = transform(x)
+        print(y.shape)
+        >> [2, 48000]
+
+    """
+    def __init__(self, transforms: List[Any], p: float = 0.5):
+        self.transforms = transforms
+        self.p = p
+
+    def __call__(self, x: Tensor) -> Tensor:
+        for t in self.transforms:
+            if random.choices([True, False], weights=[self.p, 1 - self.p])[0]:
+                x = t(x)
+        return x
+
+    def __repr__(self):
+        format_string = self.__class__.__name__ + '('
+        for t in self.transforms:
+            format_string += '\n'
+            format_string += '    {0}'.format(t)
+        format_string += f'\n), p={self.p}'
+        return format_string
+
+
+class RandomChoice():
+    """Compose a list of transforms and choice one randomly according to some weights(if proviced)
+    Parameters:
+        transforms: a list of transforms.
+    Examples:
+
+        .. code-block:: python
+
+        import paddle
+        import paddleaudio.transforms as T
+        x = paddle.randn((2, 48000))
+
+        transform1 = T.RandomCropping(target_size=16000)
+        transform2 = T.RandomMuLawCodec()
+        transform = T.RandomChoice([
+            transform1,
+            transform2,
+        ],weights=[0.3,0.7])
+        y = transform(x)
+        print(y.shape)
+        >> [2, 16000]
+
+    """
+    def __init__(self,
+                 transforms: List[Any],
+                 weights: Optional[List[float]] = None):
+        self.transforms = transforms
+        self.weights = weights
+
+    def __call__(self, x: Tensor) -> Tensor:
+        t = random.choices(self.transforms, weights=self.weights)[0]
+        return t(x)
+
+    def __repr__(self):
+        format_string = self.__class__.__name__ + '('
+        for t in self.transforms:
+            format_string += '\n'
+            format_string += '    {0}'.format(t)
+        format_string += f'\n)'
+        return format_string
+
+
+class Noisify(nn.Layer):
+    """Transform the input audio tensor by adding noise.
+
+    Parameters:
+        noise_reader: a NoiseSource object that reads audio as noise source. It should
+        be a callable object that return a noise tensor after being called.
+        snr_high(float): the upper bound of signal-to-noise ratio in db
+            after applying the transform. Default: 10.0 db.
+        snr_low(None|float): the lower bound of signal-to-noise ratio in db
+            after applying the transform. If None, it is set to snr_high*0.5.
+            Default: None
+        random(bool): whether to sample snr randomly in range [snr_low,snr_high]. If False,
+            the snr_high is used as constant snr value for all transforms. Default: False.
+
+    Shapes:
+        - x: 2-D tensor with shape [batch_size, frames]
+        - output: 2-D tensor with shape [batch_size, frames]
+
+    Examples:
+
+        .. code-block:: python
+
+        import paddle
+        import paddleaudio.transforms as T
+        x = paddle.randn((2, 48000))
+        # A noise reader should be provided, see speaker example for how to define a noise reader
+        transform = Noisify(<noise_reader>, 20, 15, True)
+        y = transform(x)
+        print(y.shape)
+        >> [2,48000]
+
+    """
+    def __init__(self,
+                 noise_reader: Any,
+                 snr_high: float = 10.0,
+                 snr_low: Optional[float] = None,
+                 random: bool = False):
+        super(Noisify, self).__init__()
+        self.noise_reader = noise_reader
+        self.random = random
+        self.snr_high = snr_high
+        self.snr_low = snr_low
+        if self.random:
+            if self.snr_low is None:
+                self.snr_low = snr_high - 3.0
+            assert self.snr_high >= self.snr_low, (
+                f'snr_high should be >= snr_low, ' +
+                f'but received snr_high={self.snr_high}, ' +
+                f'snr_low={self.snr_low}')
+
+    def forward(self, x: Tensor) -> Tensor:
+        assert x.ndim == 2, (f'the input tensor must be 2d tensor, ' +
+                             f'but received x.ndim={x.ndim}')
+        noise = self.noise_reader()
+        if self.random:
+            snr = random.uniform(self.snr_low, self.snr_high)
+        else:
+            snr = self.snr_high
+        signal_mag = paddle.sum(paddle.square(x), -1)
+        noise_mag = paddle.sum(paddle.square(noise), -1)
+        alpha = 10**(snr / 10) * noise_mag / (signal_mag + 1e-10)
+        beta = 1.0
+        factor = alpha + beta
+        alpha = alpha / factor
+        beta = beta / factor
+        x = alpha.unsqueeze((1, )) * x + beta.unsqueeze((1, )) * noise
+        return x
+
+    def __repr__(self):
+        return (
+            self.__class__.__name__ +
+            f'(random={self.random}, snr_high={self.snr_high}, snr_low={self.snr_low})'
+        )
+
+
+class MFCC(nn.Layer):
+    def __init__(self,
+                 sr: int = 22050,
+                 n_mfcc: int = 20,
+                 dct_norm: str = "ortho",
+                 lifter: int = 0,
+                 dtype: str = 'float64',
+                 **kwargs):
+        """"Compute Mel-frequency cepstral coefficients (MFCCs) give an input waveform.
+
+        Parameters:
+            sr(int): the audio sample rate.
+                    The default value is 22050.
+            n_mfcc(int): the number of coefficients.
+                The default value is 20.
+            dct_norm: the normalization type of dct matrix. See `dct_matrix` for more details.
+                The default value is 'ortho'.
+            lifter(int): if lifter > 0, apply liftering(cepstral filtering) to the MFCCs.
+                If lifter = 0, no liftering is applied.
+                Setting lifter >= 2 * n_mfcc emphasizes the higher-order coefficients.
+                As lifter increases, the coefficient weighting becomes approximately linear.
+                The default value is 0.
+            dtype(str): the datatype of used internally in computing MFCC.
+            kwargs: additional keyword arguments that will be passed to MelSpectrogram. See ```MelSpectrogram```
+                for more details. If not provided, the default values are used.
+
+        Examples:
+
+            .. code-block:: python
+
+            import paddle
+            import paddleaudio.transforms as T
+            mfcc = paddleaudio.transforms.MFCC(sr=16000,
+                                            n_mfcc=20,
+                                            n_mels=64,
+                                            n_fft=512,
+                                            win_length=512,
+                                            hop_length=160)
+
+            x = paddle.randn((8, 16000)) # the waveform
+            y = mfcc(x)
+            print(y.shape)
+            >> [8, 20, 101]
+            """
+        super(MFCC, self).__init__()
+        self.sr = sr
+        self.n_mfcc = n_mfcc
+        self.dct_norm = dct_norm
+        self.lifter = lifter
+        self.dtype = dtype
+        self._melspectrogram = MelSpectrogram(sr=sr, dtype=dtype, **kwargs)
+
+    def forward(self, x: Tensor) -> Tensor:
+
+        spect = self._melspectrogram(x)  #[batch,n_mels,frames]
+        spect = F.power_to_db(spect)
+        n_mels = spect.shape[1]
+        #import pdb;pdb.set_trace()
+        M = F.dct_matrix(self.n_mfcc,
+                         n_mels,
+                         dct_norm=self.dct_norm,
+                         dtype=self.dtype)
+
+        mfcc = M.transpose([1, 0]).unsqueeze_(0) @ spect
+
+        if self.lifter > 0:
+            factor = paddle.sin(
+                math.pi * paddle.arange(1, 1 + self.n_mfcc, dtype=self.dtype) /
+                self.lifter)
+            return mfcc @ factor.unsqueeze([0, 2])
+        elif self.lifter == 0:
+            return mfcc
+        else:
+            raise ValueError(
+                f"MFCC lifter={self.lifter} must be a non-negative number")
+        return mfcc
+
+    def __repr__(self):
+        p_repr = str(self._melspectrogram).split('(')[-1].split(')')[0]
+        return (self.__class__.__name__ + f'(sr={self.sr}, ' +
+                f'n_mfcc={self.n_mfcc}, dct_norm={self.dct_norm}, ' +
+                f'dtype={self.dtype}, ' + f'lifter={self.lifter}, ' + p_repr +
+                ')')
diff --git a/PaddleAudio/test/unit_test/test_dct_matrix.py b/PaddleAudio/test/unit_test/test_dct_matrix.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fd1a2b26735e73f27f0a0db5e2bab0c95d82ca2
--- /dev/null
+++ b/PaddleAudio/test/unit_test/test_dct_matrix.py
@@ -0,0 +1,55 @@
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import paddle
+import paddleaudio
+import scipy
+import utils
+
+
+def test_dct_compat_with_scipy1():
+
+    paddle.set_device('cpu')
+    expected = scipy.fft.dct(np.eye(64), norm='ortho')[:, :8]
+    paddle_dct = paddleaudio.functional.dct_matrix(8, 64, dct_norm='ortho')
+    err = np.mean(np.abs(paddle_dct.numpy() - expected))
+    assert err < 5e-8
+
+
+def test_dct_compat_with_scipy2():
+
+    paddle.set_device('cpu')
+    expected = scipy.fft.dct(np.eye(64), norm=None)[:, :8]
+    paddle_dct = paddleaudio.functional.dct_matrix(8, 64, dct_norm=None)
+    err = np.mean(np.abs(paddle_dct.numpy() - expected))
+    assert err < 5e-7
+
+
+def test_dct_compat_with_scipy3():
+
+    paddle.set_device('gpu')
+    expected = scipy.fft.dct(np.eye(64), norm='ortho')[:, :8]
+    paddle_dct = paddleaudio.functional.dct_matrix(8, 64, dct_norm='ortho')
+    err = np.mean(np.abs(paddle_dct.numpy() - expected))
+    assert err < 5e-7
+
+
+def test_dct_compat_with_scipy4():
+
+    paddle.set_device('gpu')
+    expected = scipy.fft.dct(np.eye(64), norm=None)[:, :8]
+    paddle_dct = paddleaudio.functional.dct_matrix(8, 64, dct_norm=None)
+    err = np.mean(np.abs(paddle_dct.numpy() - expected))
+    assert err < 5e-7
diff --git a/PaddleAudio/test/unit_test/test_functional.py b/PaddleAudio/test/unit_test/test_functional.py
index 17c056476eb751c41fbb0a77457ba641e3ba99a0..7edfbcdbb884d86109ac1249bffdf75f09d11919 100644
--- a/PaddleAudio/test/unit_test/test_functional.py
+++ b/PaddleAudio/test/unit_test/test_functional.py
@@ -24,47 +24,43 @@ import utils
 
 EPS = 1e-8
 
-
-def test_hz_mel_convert():
-    hz = np.linspace(0, 32000, 100).astype('float32')
-    mel0 = paddleaudio.utils._librosa.hz_to_mel(hz)
-    mel1 = F.hz_to_mel(paddle.to_tensor(hz)).numpy()
-    hz0 = paddleaudio.utils._librosa.mel_to_hz(mel0)
-    hz1 = F.mel_to_hz(paddle.to_tensor(mel0)).numpy()
-    assert np.allclose(hz0, hz1)
-    assert np.allclose(mel0, mel1)
-    assert np.allclose(hz, hz0)
-
-
-def generate_window_test_data():
-    names = [
-        ('hamming', ),
-        ('hann', ),
-        (
-            'taylor',
-            4,
-            30,
-            True,
-        ),
-        #'kaiser',
-        ('gaussian', 100),
-        ('exponential', None, 1.0),
-        ('triang', ),
-        ('bohman', ),
-        ('blackman', ),
-        ('cosine', ),
-    ]
-    win_length = [512, 400, 1024, 2048]
-    fftbins = [True, False]
-    return itertools.product(names, win_length, fftbins)
-
-
-@pytest.mark.parametrize('name,win_length,fftbins', generate_window_test_data())
-def test_get_window(name, win_length, fftbins):
-    src = F.get_window(name, win_length, fftbins=fftbins)
-    target = scipy.signal.get_window(name, win_length, fftbins=fftbins)
-    assert np.allclose(src.numpy(), target, atol=1e-5)
-
+# def test_hz_mel_convert():
+#     hz = np.linspace(0, 32000, 100).astype('float32')
+#     mel0 = paddleaudio.utils._librosa.hz_to_mel(hz)
+#     mel1 = F.hz_to_mel(paddle.to_tensor(hz)).numpy()
+#     hz0 = paddleaudio.utils._librosa.mel_to_hz(mel0)
+#     hz1 = F.mel_to_hz(paddle.to_tensor(mel0)).numpy()
+#     assert np.allclose(hz0, hz1)
+#     assert np.allclose(mel0, mel1)
+#     assert np.allclose(hz, hz0)
+
+# def generate_window_test_data():
+#     names = [
+#         ('hamming', ),
+#         ('hann', ),
+#         (
+#             'taylor',
+#             4,
+#             30,
+#             True,
+#         ),
+#         #'kaiser',
+#         ('gaussian', 100),
+#         ('exponential', None, 1.0),
+#         ('triang', ),
+#         ('bohman', ),
+#         ('blackman', ),
+#         ('cosine', ),
+#     ]
+#     win_length = [512, 400, 1024, 2048]
+#     fftbins = [True, False]
+#     return itertools.product(names, win_length, fftbins)
+
+# @pytest.mark.parametrize('name,win_length,fftbins', generate_window_test_data())
+# def test_get_window(name, win_length, fftbins):
+#     src = F.get_window(name, win_length, fftbins=fftbins)
+#     target = scipy.signal.get_window(name, win_length, fftbins=fftbins)
+#     assert np.allclose(src.numpy(), target, atol=1e-5)
 
 p2db_test_data = [
     (1.0, 1e-10, 80),
@@ -84,17 +80,40 @@ def test_power_to_db(ref_value, amin, top_db):
     assert np.allclose(src.numpy(), target, atol=1e-5)
 
 
-def test_mu_codec():
-    x, _ = utils.load_example_audio1()
-    x = paddle.to_tensor(x)
-    code = F.mu_law_encode(x)
-    xr = F.mu_law_decode(code)
-    assert np.allclose(xr.numpy(), x.numpy(), atol=1e-1)
+# def test_mu_codec():
+#     x, _ = utils.load_example_audio1()
+#     x = paddle.to_tensor(x)
+#     code = F.mu_law_encode(x)
+#     xr = F.mu_law_decode(code)
+#     assert np.allclose(xr.numpy(), x.numpy(), atol=1e-1)
+
+#     code = F.mu_law_encode(x, mu=1024)
+#     xr = F.mu_law_decode(code, mu=1024)
+#     assert np.allclose(xr.numpy(), x.numpy(), atol=1e-2)
+
+#     code = F.mu_law_encode(x, mu=65536)
+#     xr = F.mu_law_decode(code, mu=65536)
+#     assert np.allclose(xr.numpy(), x.numpy(), atol=1e-4)
+
+
+def test_mel_frequencies():
+    src = F.mel_frequencies(n_mels=128, f_min=0.0, f_max=11025.0, htk=False)
+    target = paddleaudio.utils._librosa.mel_frequencies(n_mels=128,
+                                                        fmin=0.0,
+                                                        fmax=11025.0,
+                                                        htk=False)
+    assert np.allclose(src.numpy(), target)
+
+
+def test_fft_frequencies():
+    src = F.fft_frequencies(16000, 512)
+    target = paddleaudio.utils._librosa.fft_frequencies(16000, 512)
+    np.allclose(src.numpy(), target)
 
-    code = F.mu_law_encode(x, mu=1024)
-    xr = F.mu_law_decode(code, mu=1024)
-    assert np.allclose(xr.numpy(), x.numpy(), atol=1e-2)
 
-    code = F.mu_law_encode(x, mu=65536)
-    xr = F.mu_law_decode(code, mu=65536)
-    assert np.allclose(xr.numpy(), x.numpy(), atol=1e-4)
+def test_fbank_matrix():
+    src = F.compute_fbank_matrix(sr=16000, n_fft=512, n_mels=128)
+    target = paddleaudio.utils._librosa.compute_fbank_matrix(sr=16000,
+                                                             n_fft=512,
+                                                             n_mels=128)
+    assert np.allclose(src.numpy(), target, atol=1e-7)  # cannot reach 1e-8
diff --git a/PaddleAudio/test/unit_test/test_melspect_librosa_compat.py b/PaddleAudio/test/unit_test/test_melspect_librosa_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..86a12608fa493525d3d2ebcffa5645a82547ed15
--- /dev/null
+++ b/PaddleAudio/test/unit_test/test_melspect_librosa_compat.py
@@ -0,0 +1,88 @@
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import itertools
+
+import librosa
+import numpy as np
+import paddle
+import paddleaudio
+import pytest
+
+
+def generate_mel_test():
+    sr = [16000]
+    n_fft = [512, 1024]
+    hop_length = [160, 400]
+    win_length = [512]
+    window = ['hann', 'hamming', ('gaussian', 50)]
+    center = [True, False]
+    pad_mode = ['reflect', 'constant']
+    power = [1.0, 2.0]
+    n_mels = [80, 64, 32]
+    fmin = [0, 10]
+    fmax = [8000, None]
+    dtype = ['float32', 'float64']
+    device = ['gpu', 'cpu']
+    args = [
+        sr, n_fft, hop_length, win_length, window, center, pad_mode, power,
+        n_mels, fmin, fmax, dtype, device
+    ]
+    return itertools.product(*args)
+
+
+@pytest.mark.parametrize(
+    'sr,n_fft,hop_length,win_length,window,center,pad_mode,power,n_mels,f_min,f_max,dtype,device',
+    generate_mel_test())
+def test_case(sr, n_fft, hop_length, win_length, window, center, pad_mode,
+              power, n_mels, f_min, f_max, dtype, device):
+
+    paddle.set_device(device)
+    signal, sr = paddleaudio.load('./test/unit_test/test_audio.wav')
+    signal_tensor = paddle.to_tensor(signal)
+    paddle_cpu_feat = paddleaudio.functional.melspectrogram(
+        signal_tensor,
+        sr=16000,
+        n_fft=n_fft,
+        hop_length=hop_length,
+        win_length=win_length,
+        window=window,
+        center=center,
+        n_mels=n_mels,
+        pad_mode=pad_mode,
+        f_min=f_min,
+        f_max=f_max,
+        htk=True,
+        norm='slaney',
+        dtype=dtype)
+
+    librosa_feat = librosa.feature.melspectrogram(signal,
+                                                  sr=16000,
+                                                  n_fft=n_fft,
+                                                  hop_length=hop_length,
+                                                  win_length=win_length,
+                                                  window=window,
+                                                  center=center,
+                                                  n_mels=n_mels,
+                                                  pad_mode=pad_mode,
+                                                  power=2.0,
+                                                  norm='slaney',
+                                                  htk=True,
+                                                  fmin=f_min,
+                                                  fmax=f_max)
+    err = np.mean(np.abs(librosa_feat - paddle_cpu_feat.numpy()))
+    if dtype == 'float64':
+        assert err < 1.0e-07
+    else:
+        assert err < 5.0e-07
diff --git a/PaddleAudio/test/unit_test/test_mfcc_librosa_compat.py b/PaddleAudio/test/unit_test/test_mfcc_librosa_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..5743e72a44116100189fa2062eb00e1875828e9d
--- /dev/null
+++ b/PaddleAudio/test/unit_test/test_mfcc_librosa_compat.py
@@ -0,0 +1,136 @@
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import itertools
+
+import librosa
+import numpy as np
+import paddle
+import paddleaudio
+import pytest
+from utils import load_example_audio1
+
+eps_float32 = 1e-3
+eps_float64 = 2.2e-5
+# Pre-loading to speed up the test
+signal, _ = load_example_audio1()
+signal_tensor = paddle.to_tensor(signal)
+
+
+def generate_mfcc_test():
+    sr = [16000]
+    n_fft = [512]  #, 1024]
+    hop_length = [160]  #, 400]
+    win_length = [512]
+    window = ['hann']  # 'hamming', ('gaussian', 50)]
+    center = [True]  #, False]
+    pad_mode = ['reflect', 'constant']
+    power = [2.0]
+    n_mels = [64]  #32]
+    fmin = [0, 10]
+    fmax = [8000, None]
+    dtype = ['float32', 'float64']
+    device = ['gpu', 'cpu']
+    n_mfcc = [40, 20]
+    htk = [True]
+    args = [
+        sr, n_fft, hop_length, win_length, window, center, pad_mode, power,
+        n_mels, fmin, fmax, dtype, device, n_mfcc, htk
+    ]
+    return itertools.product(*args)
+
+
+@pytest.mark.parametrize(
+    'sr, n_fft, hop_length, win_length, window, center, pad_mode, power,\
+        n_mels, fmin, fmax,dtype,device,n_mfcc,htk', generate_mfcc_test())
+def test_mfcc_case(sr, n_fft, hop_length, win_length, window, center, pad_mode, power,\
+        n_mels, fmin, fmax,dtype,device,n_mfcc,htk):
+    # paddle.set_device(device)
+    # hop_length = 160
+    # win_length = 512
+    # window = 'hann'
+    # pad_mode = 'constant'
+    # power = 2.0
+    # sample_rate = 16000
+    # center = True
+    # f_min = 0.0
+
+    # for librosa, the norm is default to 'slaney'
+    expected = librosa.feature.mfcc(signal,
+                                    sr=sr,
+                                    n_mfcc=n_mfcc,
+                                    n_fft=win_length,
+                                    hop_length=hop_length,
+                                    win_length=win_length,
+                                    window=window,
+                                    center=center,
+                                    n_mels=n_mels,
+                                    pad_mode=pad_mode,
+                                    fmin=fmin,
+                                    fmax=fmax,
+                                    htk=htk,
+                                    power=2.0)
+
+    paddle_mfcc = paddleaudio.functional.mfcc(signal_tensor,
+                                              sr=sr,
+                                              n_mfcc=n_mfcc,
+                                              n_fft=win_length,
+                                              hop_length=hop_length,
+                                              win_length=win_length,
+                                              window=window,
+                                              center=center,
+                                              n_mels=n_mels,
+                                              pad_mode=pad_mode,
+                                              f_min=fmin,
+                                              f_max=fmax,
+                                              htk=htk,
+                                              norm='slaney',
+                                              dtype=dtype)
+
+    paddle_librosa_diff = np.mean(np.abs(expected - paddle_mfcc.numpy()))
+    if dtype == 'float64':
+        assert paddle_librosa_diff < eps_float64
+    else:
+        assert paddle_librosa_diff < eps_float32
+
+    try:  # if we have torchaudio installed
+        import torch
+        import torchaudio
+        kwargs = {
+            'n_fft': win_length,
+            'hop_length': hop_length,
+            'win_length': win_length,
+            # 'window':window,
+            'center': center,
+            'n_mels': n_mels,
+            'pad_mode': pad_mode,
+            'f_min': fmin,
+            'f_max': fmax,
+            'mel_scale': 'htk',
+            'norm': 'slaney',
+            'power': 2.0
+        }
+        torch_mfcc_transform = torchaudio.transforms.MFCC(n_mfcc=20,
+                                                          log_mels=False,
+                                                          melkwargs=kwargs)
+        torch_mfcc = torch_mfcc_transform(torch.tensor(signal))
+        paddle_torch_mfcc_diff = np.mean(
+            np.abs(paddle_mfcc.numpy() - torch_mfcc.numpy()))
+        assert paddle_torch_mfcc_diff < 5e-5
+        torch_librosa_mfcc_diff = np.mean(np.abs(torch_mfcc.numpy() - expected))
+        assert torch_librosa_mfcc_diff < 5e-5
+    except:
+        pass
+
+
+#test_mfcc_case(512, 40, 20, True, 8000, 'cpu','float64',eps_float64)
diff --git a/PaddleAudio/test/unit_test/test_stft_librosa_compat.py b/PaddleAudio/test/unit_test/test_stft_librosa_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..153933d0df0d9cde4bd00f0f3ffefc14f6cd26db
--- /dev/null
+++ b/PaddleAudio/test/unit_test/test_stft_librosa_compat.py
@@ -0,0 +1,85 @@
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import itertools
+
+import librosa
+import numpy as np
+import paddle
+import paddleaudio
+import pytest
+from utils import load_example_audio1
+
+
+def generate_test():
+    sr = [16000]
+    n_fft = [512, 1024]
+    hop_length = [160, 400]
+    win_length = [512]
+    window = ['hann', 'hamming', ('gaussian', 50)]
+    center = [True, False]
+    pad_mode = ['reflect', 'constant']
+    dtype = ['float32', 'float64']
+    device = ['gpu', 'cpu']
+
+    args = [
+        sr, n_fft, hop_length, win_length, window, center, pad_mode, dtype,
+        device
+    ]
+    return itertools.product(*args)
+
+
+@pytest.mark.parametrize(
+    'sr,n_fft,hop_length,win_length,window,center,pad_mode,dtype,device',
+    generate_test())
+def test_case(sr, n_fft, hop_length, win_length, window, center, pad_mode,
+              dtype, device):
+
+    if dtype == 'float32':
+        if n_fft < 1024:
+            max_err = 5e-6
+        else:
+            max_err = 7e-6
+        min_err = 1e-8
+    else:  #float64
+        max_err = 6.0e-08
+        min_err = 1e-10
+
+    paddle.set_device(device)
+
+    signal, _ = load_example_audio1()
+    signal_tensor = paddle.to_tensor(signal)  #.to(device)
+
+    stft = paddleaudio.transforms.STFT(n_fft=n_fft,
+                                       hop_length=hop_length,
+                                       win_length=win_length,
+                                       window=window,
+                                       center=center,
+                                       pad_mode=pad_mode,
+                                       dtype=dtype)
+
+    paddle_feat = stft(signal_tensor.unsqueeze(0))[0]
+
+    target = paddleaudio.utils._librosa.stft(signal,
+                                             n_fft=n_fft,
+                                             win_length=win_length,
+                                             hop_length=hop_length,
+                                             window=window,
+                                             center=center,
+                                             pad_mode=pad_mode)
+    librosa_feat = np.concatenate(
+        [target.real[..., None], target.imag[..., None]], -1)
+    err = np.mean(np.abs(librosa_feat - paddle_feat.numpy()))
+
+    assert err <= max_err
+    assert err >= min_err
diff --git a/PaddleAudio/test/unit_test/test_transform.py b/PaddleAudio/test/unit_test/test_transform.py
index a3965ef55359abf24cc9ada5ff2515298254ba49..fd8fcddfc7cb9ff1c65e29be5aa642149c26faff 100644
--- a/PaddleAudio/test/unit_test/test_transform.py
+++ b/PaddleAudio/test/unit_test/test_transform.py
@@ -19,49 +19,56 @@ import pytest
 from paddleaudio.transforms import ISTFT, STFT, MelSpectrogram
 from paddleaudio.utils._librosa import melspectrogram
 
+paddle.set_device('cpu')
 EPS = 1e-8
 import itertools
 
+from utils import load_example_audio1
+
 
 # test case for stft
 def generate_stft_test():
     n_fft = [512, 1024]
     hop_length = [160, 320]
-    window = ['hann', 'hamming', ('gaussian', 100), ('tukey', 0.5),
-              'blackman']  #'bohman'
-    win_length = [512, 400]
+    window = [
+        'hann',
+        'hamming',
+        ('gaussian', 100),  #, ('tukey', 0.5),
+        'blackman'
+    ]  #'bohman'
+    win_length = [500, 400]
     pad_mode = ['reflect', 'constant']
     args = [n_fft, hop_length, window, win_length, pad_mode]
     return itertools.product(*args)
 
 
-@pytest.mark.parametrize('n_fft,hop_length,window,win_length,pad_mode',
-                         generate_stft_test())
-def test_istft(n_fft, hop_length, window, win_length, pad_mode):
-    sample_rate = 16000
-    signal_length = sample_rate * 5
-    center = True
-    signal = np.random.uniform(-1, 1, signal_length).astype('float32')
-    signal_tensor = paddle.to_tensor(signal)  #.to(device)
+# @pytest.mark.parametrize('n_fft,hop_length,window,win_length,pad_mode',
+#                          generate_stft_test())
+# def test_istft(n_fft, hop_length, window, win_length, pad_mode):
+#     sample_rate = 16000
+#     signal_length = sample_rate * 5
+#     center = True
+#     signal = np.random.uniform(-1, 1, signal_length).astype('float32')
+#     signal_tensor = paddle.to_tensor(signal)  #.to(device)
 
-    stft = STFT(n_fft=n_fft,
-                hop_length=hop_length,
-                win_length=win_length,
-                window=window,
-                center=center,
-                pad_mode=pad_mode)
+#     stft = STFT(n_fft=n_fft,
+#                 hop_length=hop_length,
+#                 win_length=win_length,
+#                 window=window,
+#                 center=center,
+#                 pad_mode=pad_mode)
 
-    spectrum = stft(signal_tensor.unsqueeze(0))
+#     spectrum = stft(signal_tensor.unsqueeze(0))
 
-    istft = ISTFT(n_fft=n_fft,
-                  hop_length=hop_length,
-                  win_length=win_length,
-                  window=window,
-                  center=center,
-                  pad_mode=pad_mode)
+#     istft = ISTFT(n_fft=n_fft,
+#                   hop_length=hop_length,
+#                   win_length=win_length,
+#                   window=window,
+#                   center=center,
+#                   pad_mode=pad_mode)
 
-    reconstructed = istft(spectrum, signal_length)
-    assert np.allclose(signal, reconstructed[0].numpy(), rtol=1e-5, atol=1e-3)
+#     reconstructed = istft(spectrum, signal_length)
+#     assert np.allclose(signal, reconstructed[0].numpy(), rtol=1e-5, atol=1e-3)
 
 
 @pytest.mark.parametrize('n_fft,hop_length,window,win_length,pad_mode',
@@ -70,6 +77,8 @@ def test_stft(n_fft, hop_length, window, win_length, pad_mode):
     sample_rate = 16000
     signal_length = sample_rate * 5
     center = True
+    #signal = paddleaudio.load('./test_audio.wav')
+    signal, _ = load_example_audio1()
     signal = np.random.uniform(-1, 1, signal_length).astype('float32')
     signal_tensor = paddle.to_tensor(signal)  #.to(device)
 
@@ -90,54 +99,54 @@ def test_stft(n_fft, hop_length, window, win_length, pad_mode):
                                              center=center,
                                              pad_mode=pad_mode)
 
-    assert np.allclose(target.real, src[:, :, 0], rtol=1e-5, atol=1e-2)
-    assert np.allclose(target.imag, src[:, :, 1], rtol=1e-5, atol=1e-2)
-
-
-def generate_mel_test():
-    sr = [16000]
-    n_fft = [512, 1024]
-    hop_length = [160, 400]
-    win_length = [512]
-    window = ['hann', 'hamming', ('gaussian', 50)]
-    center = [True, False]
-    pad_mode = ['reflect', 'constant']
-    power = [1.0, 2.0]
-    n_mels = [120, 32]
-    fmin = [0, 10]
-    fmax = [8000, None]
-    args = [
-        sr, n_fft, hop_length, win_length, window, center, pad_mode, power,
-        n_mels, fmin, fmax
-    ]
-    return itertools.product(*args)
-
-
-@pytest.mark.parametrize(
-    'sr,n_fft,hop_length,win_length,window,center,pad_mode,power,n_mels,fmin,fmax',
-    generate_mel_test())
-def test_melspectrogram(sr, n_fft, hop_length, win_length, window, center,
-                        pad_mode, power, n_mels, fmin, fmax):
-
-    melspectrogram = MelSpectrogram(sr, n_fft, hop_length, win_length, window,
-                                    center, pad_mode, power, n_mels, fmin, fmax)
-    signal_length = 32000 * 5
-    signal = np.random.uniform(-1, 1, signal_length).astype('float32')
-    signal_tensor = paddle.to_tensor(signal)  #.to(device)
-
-    src = melspectrogram(signal_tensor.unsqueeze(0))
-
-    target = librosa.feature.melspectrogram(signal,
-                                            sr=sr,
-                                            n_fft=n_fft,
-                                            win_length=win_length,
-                                            hop_length=hop_length,
-                                            window=window,
-                                            center=center,
-                                            pad_mode=pad_mode,
-                                            power=power,
-                                            n_mels=n_mels,
-                                            fmin=fmin,
-                                            fmax=fmax)
-
-    assert np.allclose(src.numpy()[0], target, atol=1e-3)
+    tol = 1e-4
+    assert np.allclose(target.real, src[:, :, 0], rtol=tol, atol=tol)
+    assert np.allclose(target.imag, src[:, :, 1], rtol=tol, atol=tol)
+
+
+# def generate_mel_test():
+#     sr = [16000]
+#     n_fft = [512, 1024]
+#     hop_length = [160, 400]
+#     win_length = [512]
+#     window = ['hann', 'hamming', ('gaussian', 50)]
+#     center = [True, False]
+#     pad_mode = ['reflect', 'constant']
+#     power = [1.0, 2.0]
+#     n_mels = [120, 32]
+#     fmin = [0, 10]
+#     fmax = [8000, None]
+#     args = [
+#         sr, n_fft, hop_length, win_length, window, center, pad_mode, power,
+#         n_mels, fmin, fmax
+#     ]
+#     return itertools.product(*args)
+
+# @pytest.mark.parametrize(
+#     'sr,n_fft,hop_length,win_length,window,center,pad_mode,power,n_mels,fmin,fmax',
+#     generate_mel_test())
+# def test_melspectrogram(sr, n_fft, hop_length, win_length, window, center,
+#                         pad_mode, power, n_mels, fmin, fmax):
+
+#     melspectrogram = MelSpectrogram(sr, n_fft, hop_length, win_length, window,
+#                                     center, pad_mode, power, n_mels, fmin, fmax)
+#     signal_length = 32000 * 5
+#     signal = np.random.uniform(-1, 1, signal_length).astype('float32')
+#     signal_tensor = paddle.to_tensor(signal)  #.to(device)
+
+#     src = melspectrogram(signal_tensor.unsqueeze(0))
+
+#     target = librosa.feature.melspectrogram(signal,
+#                                             sr=sr,
+#                                             n_fft=n_fft,
+#                                             win_length=win_length,
+#                                             hop_length=hop_length,
+#                                             window=window,
+#                                             center=center,
+#                                             pad_mode=pad_mode,
+#                                             power=power,
+#                                             n_mels=n_mels,
+#                                             fmin=fmin,
+#                                             fmax=fmax)
+
+#     assert np.allclose(src.numpy()[0], target, atol=1e-4)
diff --git a/PaddleAudio/test/unit_test/test_window.py b/PaddleAudio/test/unit_test/test_window.py
index f41d9eb33fcdb93b4c4759e10ef0db30312477b2..6ce5d2d1b03b3523ac735840199a2f5682062a7c 100644
--- a/PaddleAudio/test/unit_test/test_window.py
+++ b/PaddleAudio/test/unit_test/test_window.py
@@ -12,56 +12,75 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import itertools
+
 import numpy as np
-import paddleaudio
+import paddle
+import paddleaudio as pa
 import pytest
-import scipy
+from scipy.signal import get_window
+
+
+def test_data():
+    win_length = [256, 512, 1024]
+    sym = [True, False]
+    device = ['gpu', 'cpu']
+    dtype = ['float32', 'float64']
+    args = [win_length, sym, device, dtype]
+    return itertools.product(*args)
+
+
+@pytest.mark.parametrize('win_length,sym,device,dtype', test_data())
+def test_window(win_length, sym, device, dtype):
+    paddle.set_device(device)
+    if dtype == 'float64':
+        upper_err = 7e-8
+        lower_err = 0
+    else:
+        upper_err = 8e-8
+        lower_err = 0
+
+    src = pa.blackman_window(win_length, sym, dtype=dtype).numpy()
+    expected = get_window('blackman', win_length, not sym)
+    assert np.mean(np.abs(src - expected)) < upper_err
+    assert np.mean(np.abs(src - expected)) >= lower_err
+
+    src = pa.bohman_window(win_length, sym, dtype=dtype).numpy()
+    expected = get_window('bohman', win_length, not sym)
+    assert np.mean(np.abs(src - expected)) < upper_err
+    assert np.mean(np.abs(src - expected)) >= lower_err
+
+    src = pa.triang_window(win_length, sym, dtype=dtype).numpy()
+    expected = get_window('triang', win_length, not sym)
+    assert np.mean(np.abs(src - expected)) < upper_err
+    assert np.mean(np.abs(src - expected)) >= lower_err
+
+    src = pa.hamming_window(win_length, sym, dtype=dtype).numpy()
+    expected = get_window('hamming', win_length, not sym)
+    assert np.mean(np.abs(src - expected)) < upper_err
+    assert np.mean(np.abs(src - expected)) >= lower_err
+
+    src = pa.hann_window(win_length, sym, dtype=dtype).numpy()
+    expected = get_window('hann', win_length, not sym)
+    assert np.mean(np.abs(src - expected)) < upper_err
+    assert np.mean(np.abs(src - expected)) >= lower_err
 
-EPS = 1e-8
-test_data = [
-    (512, True),
-    (512, False),
-    (1024, True),
-    (1024, False),
-    (200, False),
-    (200, True),
-]
+    src = pa.tukey_window(win_length, 0.5, sym, dtype=dtype).numpy()
+    expected = get_window(('tukey', 0.5), win_length, not sym)
+    assert np.mean(np.abs(src - expected)) < upper_err
+    assert np.mean(np.abs(src - expected)) >= lower_err
 
+    src = pa.gaussian_window(win_length, 0.5, sym, dtype=dtype).numpy()
+    expected = get_window(('gaussian', 0.5), win_length, not sym)
+    assert np.mean(np.abs(src - expected)) < upper_err
+    assert np.mean(np.abs(src - expected)) >= lower_err
 
-@pytest.mark.parametrize('win_length,sym', test_data)
-def test_window(win_length, sym):
-    assert np.allclose(paddleaudio.blackman_window(win_length, sym).numpy(),
-                       scipy.signal.get_window('blackman', win_length, not sym),
-                       atol=1e-6)
-    assert np.allclose(paddleaudio.bohman_window(win_length, sym).numpy(),
-                       scipy.signal.get_window('bohman', win_length, not sym),
-                       atol=1e-6)
-    assert np.allclose(paddleaudio.triang_window(win_length, sym).numpy(),
-                       scipy.signal.get_window('triang', win_length, not sym),
-                       atol=1e-6)
-    assert np.allclose(paddleaudio.hamming_window(win_length, sym).numpy(),
-                       scipy.signal.get_window('hamming', win_length, not sym),
-                       atol=1e-6)
-    assert np.allclose(paddleaudio.hann_window(win_length, sym).numpy(),
-                       scipy.signal.get_window('hann', win_length, not sym),
-                       atol=1e-6)
-    assert np.allclose(paddleaudio.tukey_window(win_length, 0.5, sym).numpy(),
-                       scipy.signal.get_window(('tukey', 0.5), win_length,
-                                               not sym),
-                       atol=1e-6)
-    assert np.allclose(paddleaudio.gaussian_window(win_length, 0.5,
-                                                   sym).numpy(),
-                       scipy.signal.get_window(('gaussian', 0.5), win_length,
-                                               not sym),
-                       atol=1e-6)
-    assert np.allclose(paddleaudio.exponential_window(win_length, None, 1.0,
-                                                      sym).numpy(),
-                       scipy.signal.get_window(('exponential', None, 1.0),
-                                               win_length, not sym),
-                       atol=1e-6)
+    src = pa.exponential_window(win_length, None, 1.0, sym, dtype=dtype).numpy()
+    expected = get_window(('exponential', None, 1.0), win_length, not sym)
+    assert np.mean(np.abs(src - expected)) < upper_err
+    assert np.mean(np.abs(src - expected)) >= lower_err
 
-    assert np.allclose(paddleaudio.taylor_window(win_length, 4, 30, True,
-                                                 sym).numpy(),
-                       scipy.signal.get_window(('taylor', 4, 30, True),
-                                               win_length, not sym),
-                       atol=1e-6)
+    src = pa.taylor_window(win_length, 4, 30, True, sym, dtype=dtype).numpy()
+    expected = get_window(('taylor', 4, 30, True), win_length, not sym)
+    assert np.mean(np.abs(src - expected)) <= upper_err
+    assert np.mean(np.abs(src - expected)) >= lower_err