@scrypted/libav 1.0.169 → 1.0.171

package/opus/dnn/torch/osce/utils/layers/silk_upsampler.py

@@ -1,167 +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.
-*/
-"""
-
-""" This module implements the SILK upsampler from 16kHz to 24 or 48 kHz """
-
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-import numpy as np
-
-frac_fir = np.array(
-    [
-        [189, -600, 617, 30567, 2996, -1375, 425, -46],
-        [117, -159, -1070, 29704, 5784, -2143, 611, -71],
-        [52, 221, -2392, 28276, 8798, -2865, 773, -91],
-        [-4, 529, -3350, 26341, 11950, -3487, 896, -103],
-        [-48, 758, -3956, 23973, 15143, -3957, 967, -107],
-        [-80, 905, -4235, 21254, 18278, -4222, 972, -99],
-        [-99, 972, -4222, 18278, 21254, -4235, 905, -80],
-        [-107, 967, -3957, 15143, 23973, -3956, 758, -48],
-        [-103, 896, -3487, 11950, 26341, -3350, 529, -4],
-        [-91, 773, -2865, 8798, 28276, -2392, 221, 52],
-        [-71, 611, -2143, 5784, 29704, -1070, -159, 117],
-        [-46, 425, -1375, 2996, 30567, 617, -600, 189]
-    ],
-    dtype=np.float32
-) / 2**15
-
-
-hq_2x_up_c_even = [x / 2**16 for x in [1746, 14986, 39083 - 65536]]
-hq_2x_up_c_odd  = [x / 2**16 for x in [6854, 25769, 55542 - 65536]]
-
-
-def get_impz(coeffs, n):
-    s = 3*[0]
-    y = np.zeros(n)
-    x = 1
-
-    for i in range(n):
-        Y = x - s[0]
-        X = Y * coeffs[0]
-        tmp1 = s[0] + X
-        s[0] = x + X
-
-        Y = tmp1 - s[1]
-        X = Y * coeffs[1]
-        tmp2 = s[1] + X
-        s[1] = tmp1 + X
-
-        Y = tmp2 - s[2]
-        X = Y * (1 + coeffs[2])
-        tmp3 = s[2] + X
-        s[2] = tmp2 + X
-
-        y[i] = tmp3
-        x = 0
-
-    return y
-
-
-
-class SilkUpsampler(nn.Module):
-    SUPPORTED_TARGET_RATES = {24000, 48000}
-    SUPPORTED_SOURCE_RATES = {16000}
-    def __init__(self,
-                 fs_in=16000,
-                 fs_out=48000):
-
-        super().__init__()
-        self.fs_in = fs_in
-        self.fs_out = fs_out
-
-        if fs_in not in self.SUPPORTED_SOURCE_RATES:
-            raise ValueError(f'SilkUpsampler currently only supports upsampling from {self.SUPPORTED_SOURCE_RATES} Hz')
-
-
-        if fs_out not in self.SUPPORTED_TARGET_RATES:
-            raise ValueError(f'SilkUpsampler currently only supports upsampling to {self.SUPPORTED_TARGET_RATES} Hz')
-
-
-        # hq 2x upsampler as FIR approximation
-        hq_2x_up_even = get_impz(hq_2x_up_c_even, 128)[::-1].copy()
-        hq_2x_up_odd  = get_impz(hq_2x_up_c_odd , 128)[::-1].copy()
-
-        self.hq_2x_up_even = nn.Parameter(torch.from_numpy(hq_2x_up_even).float().view(1, 1, -1), requires_grad=False)
-        self.hq_2x_up_odd  = nn.Parameter(torch.from_numpy(hq_2x_up_odd ).float().view(1, 1, -1), requires_grad=False)
-        self.hq_2x_up_padding = [127, 0]
-
-        # interpolation filters
-        frac_01_24 = frac_fir[0]
-        frac_17_24 = frac_fir[8]
-        frac_09_24 = frac_fir[4]
-
-        self.frac_01_24 = nn.Parameter(torch.from_numpy(frac_01_24).view(1, 1, -1), requires_grad=False)
-        self.frac_17_24 = nn.Parameter(torch.from_numpy(frac_17_24).view(1, 1, -1), requires_grad=False)
-        self.frac_09_24 = nn.Parameter(torch.from_numpy(frac_09_24).view(1, 1, -1), requires_grad=False)
-
-        self.stride = 1 if fs_out == 48000 else 2
-
-    def hq_2x_up(self, x):
-
-        num_channels = x.size(1)
-
-        weight_even = torch.repeat_interleave(self.hq_2x_up_even, num_channels, 0)
-        weight_odd  = torch.repeat_interleave(self.hq_2x_up_odd , num_channels, 0)
-
-        x_pad  = F.pad(x, self.hq_2x_up_padding)
-        y_even = F.conv1d(x_pad, weight_even, groups=num_channels)
-        y_odd  = F.conv1d(x_pad, weight_odd , groups=num_channels)
-
-        y = torch.cat((y_even.unsqueeze(-1), y_odd.unsqueeze(-1)), dim=-1).flatten(2)
-
-        return y
-
-    def interpolate_3_2(self, x):
-
-        num_channels = x.size(1)
-
-        weight_01_24 = torch.repeat_interleave(self.frac_01_24, num_channels, 0)
-        weight_17_24 = torch.repeat_interleave(self.frac_17_24, num_channels, 0)
-        weight_09_24 = torch.repeat_interleave(self.frac_09_24, num_channels, 0)
-
-        x_pad = F.pad(x, [8, 0])
-        y_01_24     = F.conv1d(x_pad, weight_01_24, stride=2, groups=num_channels)
-        y_17_24     = F.conv1d(x_pad, weight_17_24, stride=2, groups=num_channels)
-        y_09_24_sh1 = F.conv1d(torch.roll(x_pad, -1, -1), weight_09_24, stride=2, groups=num_channels)
-
-
-        y = torch.cat(
-            (y_01_24.unsqueeze(-1), y_17_24.unsqueeze(-1), y_09_24_sh1.unsqueeze(-1)),
-            dim=-1).flatten(2)
-
-        return y[..., :-3]
-
-    def forward(self, x):
-
-        y_2x = self.hq_2x_up(x)
-        y_3x = self.interpolate_3_2(y_2x)
-
-        return y_3x[:, :, ::self.stride]

package/opus/dnn/torch/osce/utils/layers/td_shaper.py

@@ -1,145 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-from utils.complexity import _conv1d_flop_count
-from utils.softquant import soft_quant
-
-class TDShaper(nn.Module):
-    COUNTER = 1
-
-    def __init__(self,
-                 feature_dim,
-                 frame_size=160,
-                 avg_pool_k=4,
-                 innovate=False,
-                 pool_after=False,
-                 softquant=False,
-                 apply_weight_norm=False
-    ):
-        """
-
-        Parameters:
-        -----------
-
-
-        feature_dim : int
-            dimension of input features
-
-        frame_size : int
-            frame size
-
-        avg_pool_k : int, optional
-            kernel size and stride for avg pooling
-
-        padding : List[int, int]
-
-        """
-
-        super().__init__()
-
-
-        self.feature_dim    = feature_dim
-        self.frame_size     = frame_size
-        self.avg_pool_k     = avg_pool_k
-        self.innovate       = innovate
-        self.pool_after     = pool_after
-
-        assert frame_size % avg_pool_k == 0
-        self.env_dim = frame_size // avg_pool_k + 1
-
-        norm = torch.nn.utils.weight_norm if apply_weight_norm else lambda x, name=None: x
-
-        # feature transform
-        self.feature_alpha1_f = norm(nn.Conv1d(self.feature_dim, frame_size, 2))
-        self.feature_alpha1_t = norm(nn.Conv1d(self.env_dim, frame_size, 2))
-        self.feature_alpha2 = norm(nn.Conv1d(frame_size, frame_size, 2))
-
-        if softquant:
-            self.feature_alpha1_f = soft_quant(self.feature_alpha1_f)
-
-        if self.innovate:
-            self.feature_alpha1b = norm(nn.Conv1d(self.feature_dim + self.env_dim, frame_size, 2))
-            self.feature_alpha1c = norm(nn.Conv1d(self.feature_dim + self.env_dim, frame_size, 2))
-
-            self.feature_alpha2b = norm(nn.Conv1d(frame_size, frame_size, 2))
-            self.feature_alpha2c = norm(nn.Conv1d(frame_size, frame_size, 2))
-
-
-    def flop_count(self, rate):
-
-        frame_rate = rate / self.frame_size
-
-        shape_flops = sum([_conv1d_flop_count(x, frame_rate) for x in (self.feature_alpha1_f, self.feature_alpha1_t, self.feature_alpha2)]) + 11 * frame_rate * self.frame_size
-
-        if self.innovate:
-            inno_flops = sum([_conv1d_flop_count(x, frame_rate) for x in (self.feature_alpha1b, self.feature_alpha2b, self.feature_alpha1c, self.feature_alpha2c)]) + 22 * frame_rate * self.frame_size
-        else:
-            inno_flops = 0
-
-        return shape_flops + inno_flops
-
-    def envelope_transform(self, x):
-
-        x = torch.abs(x)
-        if self.pool_after:
-            x = torch.log(x + .5**16)
-            x = F.avg_pool1d(x, self.avg_pool_k, self.avg_pool_k)
-        else:
-            x = F.avg_pool1d(x, self.avg_pool_k, self.avg_pool_k)
-            x = torch.log(x + .5**16)
-
-        x = x.reshape(x.size(0), -1, self.env_dim - 1)
-        avg_x = torch.mean(x, -1, keepdim=True)
-
-        x = torch.cat((x - avg_x, avg_x), dim=-1)
-
-        return x
-
-    def forward(self, x, features, debug=False):
-        """ innovate signal parts with temporal shaping
-
-
-        Parameters:
-        -----------
-        x : torch.tensor
-            input signal of shape (batch_size, 1, num_samples)
-
-        features : torch.tensor
-            frame-wise features of shape (batch_size, num_frames, feature_dim)
-
-        """
-
-        batch_size = x.size(0)
-        num_frames = features.size(1)
-        num_samples = x.size(2)
-        frame_size = self.frame_size
-
-        # generate temporal envelope
-        tenv = self.envelope_transform(x)
-
-        # feature path
-        f = F.pad(features.permute(0, 2, 1), [1, 0])
-        t = F.pad(tenv.permute(0, 2, 1), [1, 0])
-        alpha = self.feature_alpha1_f(f) + self.feature_alpha1_t(t)
-        alpha = F.leaky_relu(alpha, 0.2)
-        alpha = torch.exp(self.feature_alpha2(F.pad(alpha, [1, 0])))
-        alpha = alpha.permute(0, 2, 1)
-
-        if self.innovate:
-            inno_alpha = F.leaky_relu(self.feature_alpha1b(f), 0.2)
-            inno_alpha = torch.exp(self.feature_alpha2b(F.pad(inno_alpha, [1, 0])))
-            inno_alpha = inno_alpha.permute(0, 2, 1)
-
-            inno_x = F.leaky_relu(self.feature_alpha1c(f), 0.2)
-            inno_x = torch.tanh(self.feature_alpha2c(F.pad(inno_x, [1, 0])))
-            inno_x = inno_x.permute(0, 2, 1)
-
-        # signal path
-        y = x.reshape(batch_size, num_frames, -1)
-        y = alpha * y
-
-        if self.innovate:
-            y = y + inno_alpha * inno_x
-
-        return y.reshape(batch_size, 1, num_samples)

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

@@ -1,112 +0,0 @@
-import os
-
-import torch
-import numpy as np
-
-def load_lpcnet_features(feature_file, version=2):
-    if version == 2:
-        layout = {
-            'cepstrum': [0,18],
-            'periods': [18, 19],
-            'pitch_corr': [19, 20],
-            'lpc': [20, 36]
-            }
-        frame_length = 36
-
-    elif version == 1:
-        layout = {
-            'cepstrum': [0,18],
-            'periods': [36, 37],
-            'pitch_corr': [37, 38],
-            'lpc': [39, 55],
-            }
-        frame_length = 55
-    else:
-        raise ValueError(f'unknown feature version: {version}')
-
-
-    raw_features = torch.from_numpy(np.fromfile(feature_file, dtype='float32'))
-    raw_features = raw_features.reshape((-1, frame_length))
-
-    features = torch.cat(
-        [
-            raw_features[:, layout['cepstrum'][0]   : layout['cepstrum'][1]],
-            raw_features[:, layout['pitch_corr'][0] : layout['pitch_corr'][1]]
-        ],
-        dim=1
-    )
-
-    lpcs = raw_features[:, layout['lpc'][0]   : layout['lpc'][1]]
-    periods = (0.1 + 50 * raw_features[:, layout['periods'][0] : layout['periods'][1]] + 100).long()
-
-    return {'features' : features, 'periods' : periods, 'lpcs' : lpcs}
-
-
-
-def create_new_data(signal_path, reference_data_path, new_data_path, offset=320, preemph_factor=0.85):
-    ref_data = np.memmap(reference_data_path, dtype=np.int16)
-    signal = np.memmap(signal_path, dtype=np.int16)
-
-    signal_preemph_path = os.path.splitext(signal_path)[0] + '_preemph.raw'
-    signal_preemph = np.memmap(signal_preemph_path, dtype=np.int16, mode='write', shape=signal.shape)
-
-
-    assert len(signal) % 160 == 0
-    num_frames = len(signal) // 160
-    mem = np.zeros(1)
-    for fr in range(len(signal)//160):
-        signal_preemph[fr * 160 : (fr + 1) * 160] = np.convolve(np.concatenate((mem, signal[fr * 160 : (fr + 1) * 160])), [1, -preemph_factor], mode='valid')
-        mem = signal[(fr + 1) * 160 - 1 : (fr + 1) * 160]
-
-    new_data = np.memmap(new_data_path, dtype=np.int16, mode='write', shape=ref_data.shape)
-
-    new_data[:] = 0
-    N = len(signal) - offset
-    new_data[1 : 2*N + 1: 2] = signal_preemph[offset:]
-    new_data[2 : 2*N + 2: 2] = signal_preemph[offset:]
-
-
-def parse_warpq_scores(output_file):
-    """ extracts warpq scores from output file """
-
-    with open(output_file, "r") as f:
-        lines = f.readlines()
-
-    scores = [float(line.split("WARP-Q score:")[-1]) for line in lines if line.startswith("WARP-Q score:")]
-
-    return scores
-
-
-def parse_stats_file(file):
-
-    with open(file, "r") as f:
-        lines = f.readlines()
-
-    mean     = float(lines[0].split(":")[-1])
-    bt_mean  = float(lines[1].split(":")[-1])
-    top_mean = float(lines[2].split(":")[-1])
-
-    return mean, bt_mean, top_mean
-
-def collect_test_stats(test_folder):
-    """ collects statistics for all discovered metrics from test folder """
-
-    metrics = {'pesq', 'warpq', 'pitch_error', 'voicing_error'}
-
-    results = dict()
-
-    content = os.listdir(test_folder)
-
-    stats_files = [file for file in content if file.startswith('stats_')]
-
-    for file in stats_files:
-        metric = file[len("stats_") : -len(".txt")]
-
-        if metric not in metrics:
-            print(f"warning: unknown metric {metric}")
-
-        mean, bt_mean, top_mean = parse_stats_file(os.path.join(test_folder, file))
-
-        results[metric] = [mean, bt_mean, top_mean]
-
-    return results

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

@@ -1,95 +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 torch
-from torch.nn.utils import remove_weight_norm
-
-def count_parameters(model, verbose=False):
-    total = 0
-    for name, p in model.named_parameters():
-        count = torch.ones_like(p).sum().item()
-
-        if verbose:
-            print(f"{name}: {count} parameters")
-
-        total += count
-
-    return total
-
-def count_nonzero_parameters(model, verbose=False):
-    total = 0
-    for name, p in model.named_parameters():
-        count = torch.count_nonzero(p).item()
-
-        if verbose:
-            print(f"{name}: {count} non-zero parameters")
-
-        total += count
-
-    return total
-def retain_grads(module):
-    for p in module.parameters():
-        if p.requires_grad:
-            p.retain_grad()
-
-def get_grad_norm(module, p=2):
-    norm = 0
-    for param in module.parameters():
-        if param.requires_grad:
-            norm = norm + (torch.abs(param.grad) ** p).sum()
-
-    return norm ** (1/p)
-
-def create_weights(s_real, s_gen, alpha):
-    weights = []
-    with torch.no_grad():
-        for sr, sg in zip(s_real, s_gen):
-            weight = torch.exp(alpha * (sr[-1] - sg[-1]))
-            weights.append(weight)
-
-    return weights
-
-
-def _get_candidates(module: torch.nn.Module):
-    candidates = []
-    for key in module.__dict__.keys():
-        if hasattr(module, key + '_v'):
-            candidates.append(key)
-    return candidates
-
-def remove_all_weight_norm(model : torch.nn.Module, verbose=False):
-    for name, m in model.named_modules():
-        candidates = _get_candidates(m)
-
-        for candidate in candidates:
-            try:
-                remove_weight_norm(m, name=candidate)
-                if verbose: print(f'removed weight norm on weight {name}.{candidate}')
-            except:
-                pass

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

@@ -1,153 +0,0 @@
-import numpy as np
-import scipy.signal
-
-def compute_vad_mask(x, fs, stop_db=-70):
-
-    frame_length = (fs + 49) // 50
-    x = x[: frame_length * (len(x) // frame_length)]
-
-    frames = x.reshape(-1, frame_length)
-    frame_energy = np.sum(frames ** 2, axis=1)
-    frame_energy_smooth = np.convolve(frame_energy, np.ones(5) / 5, mode='same')
-
-    max_threshold = frame_energy.max() * 10 ** (stop_db/20)
-    vactive = np.ones_like(frames)
-    vactive[frame_energy_smooth < max_threshold, :] = 0
-    vactive = vactive.reshape(-1)
-
-    filter = np.sin(np.arange(frame_length) * np.pi / (frame_length - 1))
-    filter = filter / filter.sum()
-
-    mask = np.convolve(vactive, filter, mode='same')
-
-    return x, mask
-
-def convert_mask(mask, num_frames, frame_size=160, hop_size=40):
-    num_samples = frame_size + (num_frames - 1) * hop_size
-    if len(mask) < num_samples:
-        mask = np.concatenate((mask, np.zeros(num_samples - len(mask))), dtype=mask.dtype)
-    else:
-        mask = mask[:num_samples]
-
-    new_mask = np.array([np.mean(mask[i*hop_size : i*hop_size + frame_size]) for i in range(num_frames)])
-
-    return new_mask
-
-def power_spectrum(x, window_size=160, hop_size=40, window='hamming'):
-    num_spectra = (len(x) - window_size - hop_size) // hop_size
-    window = scipy.signal.get_window(window, window_size)
-    N = window_size // 2
-
-    frames = np.concatenate([x[np.newaxis, i * hop_size : i * hop_size + window_size] for i in range(num_spectra)]) * window
-    psd = np.abs(np.fft.fft(frames, axis=1)[:, :N + 1]) ** 2
-
-    return psd
-
-
-def frequency_mask(num_bands, up_factor, down_factor):
-
-    up_mask = np.zeros((num_bands, num_bands))
-    down_mask = np.zeros((num_bands, num_bands))
-
-    for i in range(num_bands):
-        up_mask[i, : i + 1] = up_factor ** np.arange(i, -1, -1)
-        down_mask[i, i :] = down_factor ** np.arange(num_bands - i)
-
-    return down_mask @ up_mask
-
-
-def rect_fb(band_limits, num_bins=None):
-    num_bands = len(band_limits) - 1
-    if num_bins is None:
-        num_bins = band_limits[-1]
-
-    fb = np.zeros((num_bands, num_bins))
-    for i in range(num_bands):
-        fb[i, band_limits[i]:band_limits[i+1]] = 1
-
-    return fb
-
-
-def compare(x, y, apply_vad=False):
-    """ Modified version of opus_compare for 16 kHz mono signals
-
-    Args:
-        x (np.ndarray): reference input signal scaled to [-1, 1]
-        y (np.ndarray): test signal scaled to [-1, 1]
-
-    Returns:
-        float: perceptually weighted error
-    """
-    # filter bank: bark scale with minimum-2-bin bands and cutoff at 7.5 kHz
-    band_limits = [0, 2, 4, 6, 7, 9, 11, 13, 15, 18, 22, 26, 31, 36, 43, 51, 60, 75]
-    num_bands = len(band_limits) - 1
-    fb = rect_fb(band_limits, num_bins=81)
-
-    # trim samples to same size
-    num_samples = min(len(x), len(y))
-    x = x[:num_samples] * 2**15
-    y = y[:num_samples] * 2**15
-
-    psd_x = power_spectrum(x) + 100000
-    psd_y = power_spectrum(y) + 100000
-
-    num_frames = psd_x.shape[0]
-
-    # average band energies
-    be_x = (psd_x @ fb.T) / np.sum(fb, axis=1)
-
-    # frequecy masking
-    f_mask = frequency_mask(num_bands, 0.1, 0.03)
-    mask_x = be_x @ f_mask.T
-
-    # temporal masking
-    for i in range(1, num_frames):
-        mask_x[i, :] += 0.5 * mask_x[i-1, :]
-
-    # apply mask
-    masked_psd_x = psd_x + 0.1 * (mask_x @ fb)
-    masked_psd_y = psd_y + 0.1 * (mask_x @ fb)
-
-    # 2-frame average
-    masked_psd_x = masked_psd_x[1:] +  masked_psd_x[:-1]
-    masked_psd_y = masked_psd_y[1:] +  masked_psd_y[:-1]
-
-    # distortion metric
-    re = masked_psd_y / masked_psd_x
-    im = np.log(re) ** 2
-    Eb = ((im @ fb.T) / np.sum(fb, axis=1))
-    Ef = np.mean(Eb , axis=1)
-
-    if apply_vad:
-        _, mask = compute_vad_mask(x, 16000)
-        mask = convert_mask(mask, Ef.shape[0])
-    else:
-        mask = np.ones_like(Ef)
-
-    err = np.mean(np.abs(Ef[mask > 1e-6]) ** 3) ** (1/6)
-
-    return float(err)
-
-if __name__ == "__main__":
-    import argparse
-    from scipy.io import wavfile
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument('ref', type=str, help='reference wav file')
-    parser.add_argument('deg', type=str, help='degraded wav file')
-    parser.add_argument('--apply-vad', action='store_true')
-    args = parser.parse_args()
-
-
-    fs1, x = wavfile.read(args.ref)
-    fs2, y = wavfile.read(args.deg)
-
-    if max(fs1, fs2) != 16000:
-        raise ValueError('error: encountered sampling frequency diffrent from 16kHz')
-
-    x = x.astype(np.float32) / 2**15
-    y = y.astype(np.float32) / 2**15
-
-    err = compare(x, y, apply_vad=args.apply_vad)
-
-    print(f"MOC: {err}")