@scrypted/libav 1.0.170 → 1.0.171

package/opus/dnn/torch/osce/utils/pitch.py

@@ -1,122 +0,0 @@
-"""
-/* Copyright (c) 2023 Amazon
-   Written by Jan Buethe */
-/*
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-"""
-
-import numpy as np
-
-def hangover(lags, num_frames=10):
-    lags = lags.copy()
-    count = 0
-    last_lag = 0
-
-    for i in range(len(lags)):
-        lag = lags[i]
-
-        if lag == 0:
-            if count < num_frames:
-                lags[i] = last_lag
-                count += 1
-        else:
-            count = 0
-            last_lag = lag
-
-    return lags
-
-
-def smooth_pitch_lags(lags, d=2):
-
-    assert d < 4
-
-    num_silk_frames = len(lags) // 4
-
-    smoothed_lags = lags.copy()
-
-    tmp = np.arange(1, d+1)
-    kernel = np.concatenate((tmp, [d+1], tmp[::-1]), dtype=np.float32)
-    kernel = kernel / np.sum(kernel)
-
-    last = lags[0:d][::-1]
-    for i in range(num_silk_frames):
-        frame = lags[i * 4: (i+1) * 4]
-
-        if np.max(np.abs(frame)) == 0:
-            last = frame[4-d:]
-            continue
-
-        if i == num_silk_frames - 1:
-            next = frame[4-d:][::-1]
-        else:
-            next = lags[(i+1) * 4 : (i+1) * 4 + d]
-
-        if np.max(np.abs(next)) == 0:
-            next = frame[4-d:][::-1]
-
-        if np.max(np.abs(last)) == 0:
-            last = frame[0:d][::-1]
-
-        smoothed_frame = np.convolve(np.concatenate((last, frame, next), dtype=np.float32), kernel, mode='valid')
-
-        smoothed_lags[i * 4: (i+1) * 4] = np.round(smoothed_frame)
-
-        last = frame[4-d:]
-
-    return smoothed_lags
-
-def calculate_acorr_window(x, frame_size, lags, history=None, max_lag=300, radius=2, add_double_lag_acorr=False, no_pitch_threshold=32):
-    eps = 1e-9
-
-    lag_multiplier = 2 if add_double_lag_acorr else 1
-
-    if history is None:
-        history = np.zeros(lag_multiplier * max_lag + radius, dtype=x.dtype)
-
-    offset = len(history)
-
-    assert offset >= max_lag + radius
-    assert len(x) % frame_size == 0
-
-    num_frames = len(x) // frame_size
-    lags = lags.copy()
-
-    x_ext = np.concatenate((history, x), dtype=x.dtype)
-
-    d = radius
-    num_acorrs = 2 * d + 1
-    acorrs = np.zeros((num_frames, lag_multiplier * num_acorrs), dtype=x.dtype)
-
-    for idx in range(num_frames):
-        lag = lags[idx].item()
-        frame = x_ext[offset + idx * frame_size : offset + (idx + 1) * frame_size]
-
-        for k in range(lag_multiplier):
-            lag1 = (k + 1) * lag if lag >= no_pitch_threshold else lag
-            for j in range(num_acorrs):
-                past = x_ext[offset + idx * frame_size - lag1 + j - d : offset + (idx + 1) * frame_size - lag1 + j - d]
-                acorrs[idx, j + k * num_acorrs] = np.dot(frame, past) / np.sqrt(np.dot(frame, frame) * np.dot(past, past) + eps)
-
-    return acorrs, lags

package/opus/dnn/torch/osce/utils/silk_features.py

@@ -1,144 +0,0 @@
-"""
-/* Copyright (c) 2023 Amazon
-   Written by Jan Buethe */
-/*
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-"""
-
-import os
-
-import numpy as np
-import torch
-
-import scipy
-import scipy.signal
-
-from utils.pitch import hangover, calculate_acorr_window
-from utils.spec import create_filter_bank, cepstrum, log_spectrum, log_spectrum_from_lpc
-
-def spec_from_lpc(a, n_fft=128, eps=1e-9):
-    order = a.shape[-1]
-    assert order + 1 < n_fft
-
-    x = np.zeros((*a.shape[:-1], n_fft ))
-    x[..., 0] = 1
-    x[..., 1:1 + order] = -a
-
-    X = np.fft.fft(x, axis=-1)
-    X = np.abs(X[..., :n_fft//2 + 1]) ** 2
-
-    S = 1 / (X + eps)
-
-    return S
-
-def silk_feature_factory(no_pitch_value=256,
-                         acorr_radius=2,
-                         pitch_hangover=8,
-                         num_bands_clean_spec=64,
-                         num_bands_noisy_spec=18,
-                         noisy_spec_scale='opus',
-                         noisy_apply_dct=True,
-                         add_double_lag_acorr=False
-                         ):
-
-    w = scipy.signal.windows.cosine(320)
-    fb_clean_spec = create_filter_bank(num_bands_clean_spec, 320, scale='erb', round_center_bins=True, normalize=True)
-    fb_noisy_spec = create_filter_bank(num_bands_noisy_spec, 320, scale=noisy_spec_scale, round_center_bins=True, normalize=True)
-
-    def create_features(noisy, noisy_history, lpcs, gains, ltps, periods):
-
-        periods = periods.copy()
-
-        if pitch_hangover > 0:
-            periods = hangover(periods, num_frames=pitch_hangover)
-
-        periods[periods == 0] = no_pitch_value
-
-        clean_spectrum = 0.3 * log_spectrum_from_lpc(lpcs, fb=fb_clean_spec, n_fft=320)
-
-        if noisy_apply_dct:
-            noisy_cepstrum = np.repeat(
-                cepstrum(np.concatenate((noisy_history[-160:], noisy), dtype=np.float32), 320, fb_noisy_spec, w), 2, 0)
-        else:
-            noisy_cepstrum = np.repeat(
-                log_spectrum(np.concatenate((noisy_history[-160:], noisy), dtype=np.float32), 320, fb_noisy_spec, w), 2, 0)
-
-        log_gains = np.log(gains + 1e-9).reshape(-1, 1)
-
-        acorr, _ = calculate_acorr_window(noisy, 80, periods, noisy_history, radius=acorr_radius, add_double_lag_acorr=add_double_lag_acorr)
-
-        features = np.concatenate((clean_spectrum, noisy_cepstrum, acorr, ltps, log_gains), axis=-1, dtype=np.float32)
-
-        return features, periods.astype(np.int64)
-
-    return create_features
-
-
-
-def load_inference_data(path,
-                        no_pitch_value=256,
-                        skip=92,
-                        preemph=0.85,
-                        acorr_radius=2,
-                        pitch_hangover=8,
-                        num_bands_clean_spec=64,
-                        num_bands_noisy_spec=18,
-                        noisy_spec_scale='opus',
-                        noisy_apply_dct=True,
-                        add_double_lag_acorr=False,
-                        **kwargs):
-
-    print(f"[load_inference_data]: ignoring keyword arguments {kwargs.keys()}...")
-
-    lpcs    = np.fromfile(os.path.join(path, 'features_lpc.f32'), dtype=np.float32).reshape(-1, 16)
-    ltps    = np.fromfile(os.path.join(path, 'features_ltp.f32'), dtype=np.float32).reshape(-1, 5)
-    gains   = np.fromfile(os.path.join(path, 'features_gain.f32'), dtype=np.float32)
-    periods = np.fromfile(os.path.join(path, 'features_period.s16'), dtype=np.int16)
-    num_bits = np.fromfile(os.path.join(path, 'features_num_bits.s32'), dtype=np.int32).astype(np.float32).reshape(-1, 1)
-    num_bits_smooth = np.fromfile(os.path.join(path, 'features_num_bits_smooth.f32'), dtype=np.float32).reshape(-1, 1)
-
-    # load signal, add back delay and pre-emphasize
-    signal  = np.fromfile(os.path.join(path, 'noisy.s16'), dtype=np.int16).astype(np.float32) / (2 ** 15)
-    signal = np.concatenate((np.zeros(skip, dtype=np.float32), signal), dtype=np.float32)
-
-    create_features = silk_feature_factory(no_pitch_value, acorr_radius, pitch_hangover, num_bands_clean_spec, num_bands_noisy_spec, noisy_spec_scale, noisy_apply_dct, add_double_lag_acorr)
-
-    num_frames = min((len(signal) // 320) * 4, len(lpcs))
-    signal = signal[: num_frames * 80]
-    lpcs = lpcs[: num_frames]
-    ltps = ltps[: num_frames]
-    gains = gains[: num_frames]
-    periods = periods[: num_frames]
-    num_bits = num_bits[: num_frames // 4]
-    num_bits_smooth = num_bits[: num_frames // 4]
-
-    numbits = np.repeat(np.concatenate((num_bits, num_bits_smooth), axis=-1, dtype=np.float32), 4, axis=0)
-
-    features, periods = create_features(signal, np.zeros(350, dtype=signal.dtype), lpcs, gains, ltps, periods)
-
-    if preemph > 0:
-        signal[1:] -= preemph * signal[:-1]
-
-    return torch.from_numpy(signal), torch.from_numpy(features), torch.from_numpy(periods), torch.from_numpy(numbits)

package/opus/dnn/torch/osce/utils/softquant.py

@@ -1,110 +0,0 @@
-import torch
-
-@torch.no_grad()
-def compute_optimal_scale(weight):
-    with torch.no_grad():
-        n_out, n_in = weight.shape
-        assert n_in % 4 == 0
-        if n_out % 8:
-            # add padding
-            pad = n_out - n_out % 8
-            weight = torch.cat((weight, torch.zeros((pad, n_in), dtype=weight.dtype, device=weight.device)), dim=0)
-
-        weight_max_abs, _ = torch.max(torch.abs(weight), dim=1)
-        weight_max_sum, _ = torch.max(torch.abs(weight[:, : n_in : 2] + weight[:, 1 : n_in : 2]), dim=1)
-        scale_max = weight_max_abs / 127
-        scale_sum = weight_max_sum / 129
-
-        scale = torch.maximum(scale_max, scale_sum)
-
-    return scale[:n_out]
-
-@torch.no_grad()
-def q_scaled_noise(module, weight):
-    if isinstance(module, torch.nn.Conv1d):
-        w = weight.permute(0, 2, 1).flatten(1)
-        noise = torch.rand_like(w) - 0.5
-        scale = compute_optimal_scale(w)
-        noise = noise * scale.unsqueeze(-1)
-        noise = noise.reshape(weight.size(0), weight.size(2), weight.size(1)).permute(0, 2, 1)
-    elif isinstance(module, torch.nn.ConvTranspose1d):
-        i, o, k = weight.shape
-        w = weight.permute(2, 1, 0).reshape(k * o, i)
-        noise = torch.rand_like(w) - 0.5
-        scale = compute_optimal_scale(w)
-        noise = noise * scale.unsqueeze(-1)
-        noise = noise.reshape(k, o, i).permute(2, 1, 0)
-    elif len(weight.shape) == 2:
-        noise = torch.rand_like(weight) - 0.5
-        scale = compute_optimal_scale(weight)
-        noise = noise * scale.unsqueeze(-1)
-    else:
-        raise ValueError('unknown quantization setting')
-
-    return noise
-
-class SoftQuant:
-    name: str
-
-    def __init__(self, names: str, scale: float) -> None:
-        self.names = names
-        self.quantization_noise = None
-        self.scale = scale
-
-    def __call__(self, module, inputs, *args, before=True):
-        if not module.training: return
-
-        if before:
-            self.quantization_noise = dict()
-            for name in self.names:
-                weight = getattr(module, name)
-                if self.scale is None:
-                    self.quantization_noise[name] = q_scaled_noise(module, weight)
-                else:
-                    self.quantization_noise[name] = \
-                        self.scale * weight.abs().max() * (torch.rand_like(weight) - 0.5)
-                with torch.no_grad():
-                    weight.data[:] = weight + self.quantization_noise[name]
-        else:
-            for name in self.names:
-                weight = getattr(module, name)
-                with torch.no_grad():
-                    weight.data[:] = weight - self.quantization_noise[name]
-            self.quantization_noise = None
-
-    def apply(module, names=['weight'], scale=None):
-        fn = SoftQuant(names, scale)
-
-        for name in names:
-            if not hasattr(module, name):
-                raise ValueError("")
-
-        fn_before = lambda *x : fn(*x, before=True)
-        fn_after = lambda *x : fn(*x, before=False)
-        setattr(fn_before, 'sqm', fn)
-        setattr(fn_after, 'sqm', fn)
-
-
-        module.register_forward_pre_hook(fn_before)
-        module.register_forward_hook(fn_after)
-
-        module
-
-        return fn
-
-
-def soft_quant(module, names=['weight'], scale=None):
-    fn = SoftQuant.apply(module, names, scale)
-    return module
-
-def remove_soft_quant(module, names=['weight']):
-    for k, hook in module._forward_pre_hooks.items():
-        if hasattr(hook, 'sqm'):
-            if isinstance(hook.sqm, SoftQuant) and hook.sqm.names == names:
-                del module._forward_pre_hooks[k]
-    for k, hook in module._forward_hooks.items():
-        if hasattr(hook, 'sqm'):
-            if isinstance(hook.sqm, SoftQuant) and hook.sqm.names == names:
-                del module._forward_hooks[k]
-
-    return module

package/opus/dnn/torch/osce/utils/spec.py

@@ -1,210 +0,0 @@
-"""
-/* Copyright (c) 2023 Amazon
-   Written by Jan Buethe */
-/*
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-"""
-
-import math as m
-import numpy as np
-import scipy
-import scipy.fftpack
-import torch
-
-def erb(f):
-    return 24.7 * (4.37 * f + 1)
-
-def inv_erb(e):
-    return (e / 24.7 - 1) / 4.37
-
-def bark(f):
-    return 6 * m.asinh(f/600)
-
-def inv_bark(b):
-    return 600 * m.sinh(b / 6)
-
-
-scale_dict = {
-    'bark': [bark, inv_bark],
-    'erb': [erb, inv_erb]
-}
-
-def gen_filterbank(N, Fs=16000, keep_size=False):
-    in_freq = (np.arange(N+1, dtype='float32')/N*Fs/2)[None,:]
-    M = N + 1 if keep_size else N
-    out_freq = (np.arange(M, dtype='float32')/N*Fs/2)[:,None]
-    #ERB from B.C.J Moore, An Introduction to the Psychology of Hearing, 5th Ed., page 73.
-    ERB_N = 24.7 + .108*in_freq
-    delta = np.abs(in_freq-out_freq)/ERB_N
-    center = (delta<.5).astype('float32')
-    R = -12*center*delta**2 + (1-center)*(3-12*delta)
-    RE = 10.**(R/10.)
-    norm = np.sum(RE, axis=1)
-    RE = RE/norm[:, np.newaxis]
-    return torch.from_numpy(RE)
-
-def create_filter_bank(num_bands, n_fft=320, fs=16000, scale='bark', round_center_bins=False, return_upper=False, normalize=False):
-
-    f0 = 0
-    num_bins = n_fft // 2 + 1
-    f1 = fs / n_fft * (num_bins - 1)
-    fstep = fs / n_fft
-
-    if scale == 'opus':
-        bins_5ms = [0,  1,  2,  3,  4,  5,  6,  7,  8, 10, 12, 14, 16, 20, 24, 28, 34, 40]
-        fac = 1000 * n_fft / fs / 5
-        if num_bands != 18:
-            print("warning: requested Opus filter bank with num_bands != 18. Adjusting num_bands.")
-            num_bands = 18
-        center_bins = np.array([fac * bin for bin in bins_5ms])
-    else:
-        to_scale, from_scale = scale_dict[scale]
-
-        s0 = to_scale(f0)
-        s1 = to_scale(f1)
-
-        center_freqs = np.array([f0] + [from_scale(s0 + i * (s1 - s0) / (num_bands)) for i in range(1, num_bands - 1)] + [f1])
-        center_bins  = (center_freqs - f0) / fstep
-
-    if round_center_bins:
-        center_bins = np.round(center_bins)
-
-    filter_bank = np.zeros((num_bands, num_bins))
-
-    band = 0
-    for bin in range(num_bins):
-        # update band index
-        if bin > center_bins[band + 1]:
-            band += 1
-
-        # calculate filter coefficients
-        frac = (center_bins[band + 1] - bin) / (center_bins[band + 1] - center_bins[band])
-        filter_bank[band][bin]     = frac
-        filter_bank[band + 1][bin] = 1 - frac
-
-    if return_upper:
-        extend = n_fft - num_bins
-        filter_bank = np.concatenate((filter_bank, np.fliplr(filter_bank[:, 1:extend+1])), axis=1)
-
-    if normalize:
-        filter_bank = filter_bank / np.sum(filter_bank, axis=1).reshape(-1, 1)
-
-    return filter_bank
-
-
-def compressed_log_spec(pspec):
-
-    lpspec = np.zeros_like(pspec)
-    num_bands = pspec.shape[-1]
-
-    log_max = -2
-    follow = -2
-
-    for i in range(num_bands):
-        tmp = np.log10(pspec[i] + 1e-9)
-        tmp = max(log_max, max(follow - 2.5, tmp))
-        lpspec[i] = tmp
-        log_max = max(log_max, tmp)
-        follow = max(follow - 2.5, tmp)
-
-    return lpspec
-
-def log_spectrum_from_lpc(a, fb=None, n_fft=320, eps=1e-9, gamma=1, compress=False, power=1):
-    """ calculates cepstrum from SILK lpcs """
-    order = a.shape[-1]
-    assert order + 1 < n_fft
-
-    a = a * (gamma ** (1 + np.arange(order))).astype(np.float32)
-
-    x = np.zeros((*a.shape[:-1], n_fft ))
-    x[..., 0] = 1
-    x[..., 1:1 + order] = -a
-
-    X = np.fft.fft(x, axis=-1)
-    X = np.abs(X[..., :n_fft//2 + 1]) ** power
-
-    S = 1 / (X + eps)
-
-    if fb is None:
-        Sf = S
-    else:
-        Sf = np.matmul(S, fb.T)
-
-    if compress:
-        Sf = np.apply_along_axis(compressed_log_spec, -1, Sf)
-    else:
-        Sf = np.log(Sf + eps)
-
-    return Sf
-
-def cepstrum_from_lpc(a, fb=None, n_fft=320, eps=1e-9, gamma=1, compress=False):
-    """ calculates cepstrum from SILK lpcs """
-
-    Sf = log_spectrum_from_lpc(a, fb, n_fft, eps, gamma, compress)
-
-    cepstrum = scipy.fftpack.dct(Sf, 2, norm='ortho')
-
-    return cepstrum
-
-
-
-def log_spectrum(x, frame_size, fb=None, window=None, power=1):
-    """ calculate cepstrum on 50% overlapping frames """
-
-    assert(2*len(x)) % frame_size == 0
-    assert frame_size % 2 == 0
-
-    n = len(x)
-    num_even = n // frame_size
-    num_odd  = (n - frame_size // 2) // frame_size
-    num_bins = frame_size // 2 + 1
-
-    x_even = x[:num_even * frame_size].reshape(-1, frame_size)
-    x_odd  = x[frame_size//2 : frame_size//2 + frame_size *  num_odd].reshape(-1, frame_size)
-
-    x_unfold = np.empty((x_even.size + x_odd.size), dtype=x.dtype).reshape((-1, frame_size))
-    x_unfold[::2, :] = x_even
-    x_unfold[1::2, :] = x_odd
-
-    if window is not None:
-        x_unfold *= window.reshape(1, -1)
-
-    X = np.abs(np.fft.fft(x_unfold, n=frame_size, axis=-1))[:, :num_bins] ** power
-
-    if fb is not None:
-        X = np.matmul(X, fb.T)
-
-
-    return np.log(X + 1e-9)
-
-
-def cepstrum(x, frame_size, fb=None, window=None):
-    """ calculate cepstrum on 50% overlapping frames """
-
-    X = log_spectrum(x, frame_size, fb, window)
-
-    cepstrum = scipy.fftpack.dct(X, 2, norm='ortho')
-
-    return cepstrum