@scrypted/libav 1.0.166 → 1.0.168

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

@@ -0,0 +1,122 @@
+"""
+/* 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

@@ -0,0 +1,144 @@
+"""
+/* 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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,210 @@
+"""
+/* 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