@scrypted/libav 1.0.167 → 1.0.169

package/opus/dnn/torch/osce/scripts/concatenator.py

@@ -0,0 +1,85 @@
+import os
+import argparse
+
+import numpy as np
+from scipy import signal
+from scipy.io import wavfile
+import resampy
+
+
+
+
+parser = argparse.ArgumentParser()
+
+parser.add_argument("filelist", type=str, help="file with filenames for concatenation in WAVE format")
+parser.add_argument("target_fs", type=int, help="target sampling rate of concatenated file")
+parser.add_argument("output", type=str, help="binary output file (integer16)")
+parser.add_argument("--basedir", type=str, help="basedir for filenames in filelist, defaults to ./", default="./")
+parser.add_argument("--normalize", action="store_true", help="apply normalization")
+parser.add_argument("--db_max", type=float, help="max DB for random normalization", default=0)
+parser.add_argument("--db_min", type=float, help="min DB for random normalization", default=0)
+parser.add_argument("--verbose", action="store_true")
+
+def read_filelist(basedir, filelist):
+    with open(filelist, "r") as f:
+        files = f.readlines()
+
+    fullfiles = [os.path.join(basedir, f.rstrip('\n')) for f in files if len(f.rstrip('\n')) > 0]
+
+    return fullfiles
+
+def read_wave(file, target_fs):
+    fs, x = wavfile.read(file)
+
+    if fs < target_fs:
+        return None
+        print(f"[read_wave] warning: file {file} will be up-sampled from {fs} to {target_fs} Hz")
+
+    if fs != target_fs:
+        x = resampy.resample(x, fs, target_fs)
+
+    return x.astype(np.float32)
+
+def random_normalize(x, db_min, db_max, max_val=2**15 - 1):
+    db = np.random.uniform(db_min, db_max, 1)
+    m = np.abs(x).max()
+    c = 10**(db/20) * max_val / m
+
+    return c * x
+
+
+def concatenate(filelist : str, output : str, target_fs: int, normalize=True, db_min=0, db_max=0, verbose=False):
+
+    overlap_size = int(40 * target_fs / 8000)
+    overlap_mem = np.zeros(overlap_size, dtype=np.float32)
+    overlap_win1 = (0.5 + 0.5 * np.cos(np.arange(0, overlap_size) * np.pi / overlap_size)).astype(np.float32)
+    overlap_win2 = np.flipud(overlap_win1)
+
+    with open(output, 'wb') as f:
+        for file in filelist:
+            x = read_wave(file, target_fs)
+            if x is None: continue
+
+            if len(x) < 10 * overlap_size:
+                if verbose: print(f"skipping {file}...")
+                continue
+            elif verbose:
+                print(f"processing {file}...")
+
+            if normalize:
+                x = random_normalize(x, db_min, db_max)
+
+            x1 = x[:-overlap_size]
+            x1[:overlap_size] = overlap_win1 * overlap_mem + overlap_win2 * x1[:overlap_size]
+
+            f.write(x1.astype(np.int16).tobytes())
+
+            overlap_mem = x1[-overlap_size]
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    filelist = read_filelist(args.basedir, args.filelist)
+
+    concatenate(filelist, args.output, args.target_fs, normalize=args.normalize, db_min=args.db_min, db_max=args.db_max, verbose=args.verbose)

package/opus/dnn/torch/osce/silk_16_to_48.py

@@ -0,0 +1,28 @@
+import argparse
+
+from scipy.io import wavfile
+import torch
+import numpy as np
+
+from utils.layers.silk_upsampler import SilkUpsampler
+
+parser = argparse.ArgumentParser()
+parser.add_argument("input", type=str, help="input wave file")
+parser.add_argument("output", type=str, help="output wave file")
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+    
+    fs, x = wavfile.read(args.input)
+
+    # being lazy for now
+    assert fs == 16000 and x.dtype == np.int16
+    
+    x = torch.from_numpy(x.astype(np.float32)).view(1, 1, -1)
+    
+    upsampler = SilkUpsampler()
+    y = upsampler(x)
+    
+    y = y.squeeze().numpy().astype(np.int16)
+    
+    wavfile.write(args.output, 48000, y[13:])

package/opus/dnn/torch/osce/stndrd/evaluation/commonvoice_clip_selection.py

@@ -0,0 +1,123 @@
+import argparse
+import os
+import yaml
+import subprocess
+
+import numpy as np
+
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument('commonvoice_base_dir')
+parser.add_argument('output_dir')
+parser.add_argument('--clips-per-language', required=False, type=int, default=10)
+parser.add_argument('--seed', required=False, type=int, default=2024)
+
+
+def select_clips(dir, num_clips=10):
+
+    if num_clips % 2:
+        print(f"warning: number of clips will be reduced to {num_clips - 1}")
+    female = dict()
+    male = dict()
+
+    clips = np.genfromtxt(os.path.join(dir, 'validated.tsv'), delimiter='\t', dtype=str, invalid_raise=False)
+    clips_by_client = dict()
+
+    if len(clips.shape) < 2 or len(clips) < num_clips:
+        # not enough data to proceed
+        return None
+
+    for client in set(clips[1:,0]):
+        client_clips = clips[clips[:, 0] == client]
+        f, m = False, False
+        if 'female_feminine' in client_clips[:, 8]:
+            female[client] = client_clips[client_clips[:, 8] == 'female_feminine']
+            f = True
+        if 'male_masculine' in client_clips[:, 8]:
+            male[client] = client_clips[client_clips[:, 8] == 'male_masculine']
+            m = True
+
+        if f and m:
+            print(f"both male and female clips under client {client}")
+
+
+    if min(len(female), len(male)) < num_clips // 2:
+        return None
+
+    # select num_clips // 2 random female clients
+    female_client_selection = np.array(list(female.keys()), dtype=str)[np.random.choice(len(female), num_clips//2, replace=False)]
+    female_clip_selection = []
+    for c in female_client_selection:
+        s_idx = np.random.randint(0, len(female[c]))
+        female_clip_selection.append(os.path.join(dir, 'clips', female[c][s_idx, 1].item()))
+
+    # select num_clips // 2 random female clients
+    male_client_selection = np.array(list(male.keys()), dtype=str)[np.random.choice(len(male), num_clips//2, replace=False)]
+    male_clip_selection = []
+    for c in male_client_selection:
+        s_idx = np.random.randint(0, len(male[c]))
+        male_clip_selection.append(os.path.join(dir, 'clips', male[c][s_idx, 1].item()))
+
+    return female_clip_selection + male_clip_selection
+
+def ffmpeg_available():
+    try:
+        x = subprocess.run(['ffmpeg', '-h'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return x.returncode == 0
+    except:
+        return False
+
+
+def convert_clips(selection, outdir):
+    if not ffmpeg_available():
+        raise RuntimeError("ffmpeg not available")
+
+    clipdir = os.path.join(outdir, 'clips')
+    os.makedirs(clipdir, exist_ok=True)
+
+    clipdict = dict()
+
+    for lang, clips in selection.items():
+        clipdict[lang] = []
+        for clip in clips:
+            clipname = os.path.splitext(os.path.split(clip)[-1])[0]
+            target_name = os.path.join('clips', clipname + '.wav')
+            call_args = ['ffmpeg', '-i', clip, '-ar', '16000', os.path.join(outdir, target_name)]
+            print(call_args)
+            r = subprocess.run(call_args, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            if r.returncode != 0:
+                raise RuntimeError(f'could not execute {call_args}')
+            clipdict[lang].append(target_name)
+
+    return clipdict
+
+
+if __name__ == "__main__":
+    if not ffmpeg_available():
+        raise RuntimeError("ffmpeg not available")
+
+    args = parser.parse_args()
+
+    base_dir = args.commonvoice_base_dir
+    output_dir = args.output_dir
+    seed = args.seed
+
+    np.random.seed(seed)
+
+    langs = os.listdir(base_dir)
+    selection = dict()
+
+    for lang in langs:
+        print(f"processing {lang}...")
+        clips = select_clips(os.path.join(base_dir, lang))
+        if clips is not None:
+            selection[lang] = clips
+
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    clips = convert_clips(selection, output_dir)
+
+    with open(os.path.join(output_dir, 'clips.yml'), 'w') as f:
+        yaml.dump(clips, f)

package/opus/dnn/torch/osce/stndrd/evaluation/create_input_data.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+
+INPUT="dataset/LibriSpeech"
+OUTPUT="testdata"
+OPUSDEMO="/local/experiments/ietf_enhancement_studies/bin/opus_demo_patched"
+BITRATES=( 6000 7500 ) # 9000 12000 15000 18000 24000 32000 )
+
+
+mkdir -p $OUTPUT
+
+for fn in $(find $INPUT -name "*.wav")
+do
+    name=$(basename ${fn%*.wav})
+    sox $fn -r 16000 -b 16 -e signed-integer ${OUTPUT}/tmp.raw
+    for br in ${BITRATES[@]}
+    do
+        folder=${OUTPUT}/"${name}_${br}.se"
+        echo "creating ${folder}..."
+        mkdir -p $folder
+        cp ${OUTPUT}/tmp.raw ${folder}/clean.s16
+        (cd ${folder} && $OPUSDEMO voip 16000 1 $br clean.s16 noisy.s16)
+    done
+    rm -f ${OUTPUT}/tmp.raw
+done

package/opus/dnn/torch/osce/stndrd/evaluation/env.rc

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+export PYTHON=/home/ubuntu/opt/miniconda3/envs/torch/bin/python
+export LACE="/local/experiments/ietf_enhancement_studies/checkpoints/lace_checkpoint.pth"
+export NOLACE="/local/experiments/ietf_enhancement_studies/checkpoints/nolace_checkpoint.pth"
+export TESTMODEL="/local/experiments/ietf_enhancement_studies/opus/dnn/torch/osce/test_model.py"
+export OPUSDEMO="/local/experiments/ietf_enhancement_studies/bin/opus_demo_patched"

package/opus/dnn/torch/osce/stndrd/evaluation/evaluate.py

@@ -0,0 +1,113 @@
+"""
+/* 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 argparse
+
+
+from scipy.io import wavfile
+from pesq import pesq
+import numpy as np
+from moc import compare
+from moc2 import compare as compare2
+#from warpq import compute_WAPRQ as warpq
+from lace_loss_metric import compare as laceloss_compare
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument('folder', type=str, help='folder with processed items')
+parser.add_argument('metric', type=str, choices=['pesq', 'moc', 'moc2', 'laceloss'], help='metric to be used for evaluation')
+
+
+def get_bitrates(folder):
+    with open(os.path.join(folder, 'bitrates.txt')) as f:
+        x = f.read()
+
+    bitrates = [int(y) for y in x.rstrip('\n').split()]
+
+    return bitrates
+
+def get_itemlist(folder):
+    with open(os.path.join(folder, 'items.txt')) as f:
+        lines = f.readlines()
+
+    items = [x.split()[0] for x in lines]
+
+    return items
+
+
+def process_item(folder, item, bitrate, metric):
+    fs, x_clean  = wavfile.read(os.path.join(folder, 'clean', f"{item}_{bitrate}_clean.wav"))
+    fs, x_opus   = wavfile.read(os.path.join(folder, 'opus', f"{item}_{bitrate}_opus.wav"))
+    fs, x_lace   = wavfile.read(os.path.join(folder, 'lace', f"{item}_{bitrate}_lace.wav"))
+    fs, x_nolace = wavfile.read(os.path.join(folder, 'nolace', f"{item}_{bitrate}_nolace.wav"))
+
+    x_clean  = x_clean.astype(np.float32) / 2**15
+    x_opus   = x_opus.astype(np.float32) / 2**15
+    x_lace   = x_lace.astype(np.float32) / 2**15
+    x_nolace = x_nolace.astype(np.float32) / 2**15
+
+    if metric == 'pesq':
+        result = [pesq(fs, x_clean, x_opus), pesq(fs, x_clean, x_lace), pesq(fs, x_clean, x_nolace)]
+    elif metric =='moc':
+        result = [compare(x_clean, x_opus), compare(x_clean, x_lace), compare(x_clean, x_nolace)]
+    elif metric =='moc2':
+        result = [compare2(x_clean, x_opus), compare2(x_clean, x_lace), compare2(x_clean, x_nolace)]
+    # elif metric == 'warpq':
+        # result = [warpq(x_clean, x_opus), warpq(x_clean, x_lace), warpq(x_clean, x_nolace)]
+    elif metric == 'laceloss':
+        result = [laceloss_compare(x_clean, x_opus), laceloss_compare(x_clean, x_lace), laceloss_compare(x_clean, x_nolace)]
+    else:
+        raise ValueError(f'unknown metric {metric}')
+
+    return result
+
+def process_bitrate(folder, items, bitrate, metric):
+    results = np.zeros((len(items), 3))
+
+    for i, item in enumerate(items):
+        results[i, :] = np.array(process_item(folder, item, bitrate, metric))
+
+    return results
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    items = get_itemlist(args.folder)
+    bitrates = get_bitrates(args.folder)
+
+    results = dict()
+    for br in bitrates:
+        print(f"processing bitrate {br}...")
+        results[br] = process_bitrate(args.folder, items, br, args.metric)
+
+    np.save(os.path.join(args.folder, f'results_{args.metric}.npy'), results)
+
+    print("Done.")