@scrypted/libav 1.0.170 → 1.0.171

package/opus/dnn/torch/neural-pitch/export_neuralpitch_weights.py

@@ -1,109 +0,0 @@
-"""
-/* Copyright (c) 2022 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
-import sys
-
-sys.path.append(os.path.join(os.path.dirname(__file__), '../weight-exchange'))
-
-
-parser = argparse.ArgumentParser()
-
-parser.add_argument('checkpoint', type=str, help='model checkpoint')
-parser.add_argument('output_dir', type=str, help='output folder')
-
-args = parser.parse_args()
-
-import torch
-import numpy as np
-
-from models import PitchDNN
-from wexchange.torch import dump_torch_weights
-from wexchange.c_export import CWriter, print_vector
-
-def c_export(args, model):
-
-    message = f"Auto generated from checkpoint {os.path.basename(args.checkpoint)}"
-
-    writer = CWriter(os.path.join(args.output_dir, "pitchdnn_data"), message=message, model_struct_name='PitchDNN')
-    writer.header.write(
-f"""
-#include "opus_types.h"
-"""
-        )
-
-    dense_layers = [
-        ('if_upsample.0', "dense_if_upsampler_1"),
-        ('if_upsample.2', "dense_if_upsampler_2"),
-        ('downsample.0', "dense_downsampler"),
-        ("upsample.0", "dense_final_upsampler")
-    ]
-
-
-    for name, export_name in dense_layers:
-        layer = model.get_submodule(name)
-        dump_torch_weights(writer, layer, name=export_name, verbose=True, quantize=True, scale=None)
-
-    conv_layers = [
-        ('conv.1', "conv2d_1"),
-        ('conv.4', "conv2d_2")
-    ]
-
-
-    for name, export_name in conv_layers:
-        layer = model.get_submodule(name)
-        dump_torch_weights(writer, layer, name=export_name, verbose=True)
-
-
-    gru_layers = [
-        ("GRU", "gru_1"),
-    ]
-
-    max_rnn_units = max([dump_torch_weights(writer, model.get_submodule(name), export_name, verbose=True, input_sparse=False, quantize=True, scale=None, recurrent_scale=None)
-                             for name, export_name in gru_layers])
-
-    writer.header.write(
-f"""
-
-#define PITCH_DNN_MAX_RNN_UNITS {max_rnn_units}
-
-"""
-        )
-
-    writer.close()
-
-
-if __name__ == "__main__":
-
-    os.makedirs(args.output_dir, exist_ok=True)
-    model = PitchDNN()
-    checkpoint = torch.load(args.checkpoint, map_location='cpu')
-    model.load_state_dict(checkpoint['state_dict'])
-    c_export(args, model)

package/opus/dnn/torch/neural-pitch/models.py

@@ -1,178 +0,0 @@
-"""
-Pitch Estimation Models and dataloaders
-    - Classification Based (Input features, output logits)
-"""
-
-import torch
-import numpy as np
-
-class PitchDNNIF(torch.nn.Module):
-
-    def __init__(self, input_dim=88, gru_dim=64, output_dim=192):
-        super().__init__()
-
-        self.activation = torch.nn.Tanh()
-        self.initial = torch.nn.Linear(input_dim, gru_dim)
-        self.hidden = torch.nn.Linear(gru_dim, gru_dim)
-        self.gru = torch.nn.GRU(input_size=gru_dim, hidden_size=gru_dim, batch_first=True)
-        self.upsample = torch.nn.Linear(gru_dim, output_dim)
-
-    def forward(self, x):
-
-        x = self.initial(x)
-        x = self.activation(x)
-        x = self.hidden(x)
-        x = self.activation(x)
-        x,_ = self.gru(x)
-        x = self.upsample(x)
-        x = self.activation(x)
-        x = x.permute(0,2,1)
-
-        return x
-
-class PitchDNNXcorr(torch.nn.Module):
-
-    def __init__(self, input_dim=90, gru_dim=64, output_dim=192):
-        super().__init__()
-
-        self.activation = torch.nn.Tanh()
-
-        self.conv = torch.nn.Sequential(
-            torch.nn.ZeroPad2d((2, 0, 1, 1)),
-            torch.nn.Conv2d(1, 8, 3, bias=True),
-            self.activation,
-            torch.nn.ZeroPad2d((2,0,1,1)),
-            torch.nn.Conv2d(8, 8, 3, bias=True),
-            self.activation,
-            torch.nn.ZeroPad2d((2,0,1,1)),
-            torch.nn.Conv2d(8, 1, 3, bias=True),
-            self.activation,
-        )
-
-        self.downsample = torch.nn.Sequential(
-            torch.nn.Linear(input_dim, gru_dim),
-            self.activation
-        )
-        self.GRU = torch.nn.GRU(input_size=gru_dim, hidden_size=gru_dim, num_layers=1, batch_first=True)
-        self.upsample = torch.nn.Sequential(
-            torch.nn.Linear(gru_dim,output_dim),
-            self.activation
-        )
-
-    def forward(self, x):
-        x = self.conv(x.unsqueeze(-1).permute(0,3,2,1)).squeeze(1)
-        x,_ = self.GRU(self.downsample(x.permute(0,2,1)))
-        x = self.upsample(x).permute(0,2,1)
-
-        return x
-
-class PitchDNN(torch.nn.Module):
-    """
-    Joint IF-xcorr
-    1D CNN on IF, merge with xcorr, 2D CNN on merged + GRU
-    """
-
-    def __init__(self,input_IF_dim=88, input_xcorr_dim=224, gru_dim=64, output_dim=192):
-        super().__init__()
-
-        self.activation = torch.nn.Tanh()
-
-        self.if_upsample = torch.nn.Sequential(
-            torch.nn.Linear(input_IF_dim,64),
-            self.activation,
-            torch.nn.Linear(64,64),
-            self.activation,
-        )
-
-        self.conv = torch.nn.Sequential(
-            torch.nn.ZeroPad2d((2,0,1,1)),
-            torch.nn.Conv2d(1, 4, 3, bias=True),
-            self.activation,
-            torch.nn.ZeroPad2d((2,0,1,1)),
-            torch.nn.Conv2d(4, 1, 3, bias=True),
-            self.activation,
-        )
-
-        self.downsample = torch.nn.Sequential(
-            torch.nn.Linear(64 + input_xcorr_dim, gru_dim),
-            self.activation
-        )
-        self.GRU = torch.nn.GRU(input_size=gru_dim, hidden_size=gru_dim, num_layers=1, batch_first=True)
-        self.upsample = torch.nn.Sequential(
-            torch.nn.Linear(gru_dim, output_dim)
-        )
-
-    def forward(self, x):
-        xcorr_feat = x[:,:,:224]
-        if_feat = x[:,:,224:]
-        xcorr_feat = self.conv(xcorr_feat.unsqueeze(-1).permute(0,3,2,1)).squeeze(1).permute(0,2,1)
-        if_feat = self.if_upsample(if_feat)
-        x = torch.cat([xcorr_feat,if_feat],axis = - 1)
-        x,_ = self.GRU(self.downsample(x))
-        x = self.upsample(x).permute(0,2,1)
-
-        return x
-
-
-# Dataloaders
-class Loader(torch.utils.data.Dataset):
-      def __init__(self, features_if, file_pitch, confidence_threshold=0.4, dimension_if=30, context=100):
-            self.if_feat = np.memmap(features_if, dtype=np.float32).reshape(-1,3*dimension_if)
-
-            # Resolution of 20 cents
-            self.cents = np.rint(np.load(file_pitch)[0,:]/20)
-            self.cents = np.clip(self.cents,0,179)
-            self.confidence = np.load(file_pitch)[1,:]
-
-            # Filter confidence for CREPE
-            self.confidence[self.confidence < confidence_threshold] = 0
-            self.context = context
-            # Clip both to same size
-            size_common = min(self.if_feat.shape[0], self.cents.shape[0])
-            self.if_feat = self.if_feat[:size_common,:]
-            self.cents = self.cents[:size_common]
-            self.confidence = self.confidence[:size_common]
-
-            frame_max = self.if_feat.shape[0]//context
-            self.if_feat = np.reshape(self.if_feat[:frame_max*context, :],(frame_max, context,3*dimension_if))
-            self.cents = np.reshape(self.cents[:frame_max * context],(frame_max, context))
-            self.confidence = np.reshape(self.confidence[:frame_max*context],(frame_max, context))
-
-      def __len__(self):
-            return self.if_feat.shape[0]
-
-      def __getitem__(self, index):
-            return torch.from_numpy(self.if_feat[index,:,:]), torch.from_numpy(self.cents[index]), torch.from_numpy(self.confidence[index])
-
-class PitchDNNDataloader(torch.utils.data.Dataset):
-      def __init__(self, features, file_pitch, confidence_threshold=0.4, context=100, choice_data='both'):
-            self.feat = np.memmap(features, mode='r', dtype=np.int8).reshape(-1,312)
-            self.xcorr = self.feat[:,:224]
-            self.if_feat = self.feat[:,224:]
-            ground_truth = np.memmap(file_pitch, mode='r', dtype=np.float32).reshape(-1,2)
-            self.cents = np.rint(60*np.log2(ground_truth[:,0]/62.5))
-            mask = (self.cents>=0).astype('float32') * (self.cents<=180).astype('float32')
-            self.cents = np.clip(self.cents,0,179)
-            self.confidence = ground_truth[:,1] * mask
-            # Filter confidence for CREPE
-            self.confidence[self.confidence < confidence_threshold] = 0
-            self.context = context
-
-            self.choice_data = choice_data
-
-            frame_max = self.if_feat.shape[0]//context
-            self.if_feat = np.reshape(self.if_feat[:frame_max*context,:], (frame_max, context, 88))
-            self.cents = np.reshape(self.cents[:frame_max*context], (frame_max,context))
-            self.xcorr = np.reshape(self.xcorr[:frame_max*context,:], (frame_max,context, 224))
-            self.confidence = np.reshape(self.confidence[:frame_max*context], (frame_max, context))
-
-      def __len__(self):
-            return self.if_feat.shape[0]
-
-      def __getitem__(self, index):
-            if self.choice_data == 'both':
-                return torch.cat([torch.from_numpy((1./127)*self.xcorr[index,:,:]), torch.from_numpy((1./127)*self.if_feat[index,:,:])], dim=-1), torch.from_numpy(self.cents[index]), torch.from_numpy(self.confidence[index])
-            elif self.choice_data == 'if':
-                return torch.from_numpy((1./127)*self.if_feat[index,:,:]),torch.from_numpy(self.cents[index]),torch.from_numpy(self.confidence[index])
-            else:
-                return torch.from_numpy((1./127)*self.xcorr[index,:,:]),torch.from_numpy(self.cents[index]),torch.from_numpy(self.confidence[index])

package/opus/dnn/torch/neural-pitch/neural_pitch_update.py

@@ -1,179 +0,0 @@
-import argparse
-parser = argparse.ArgumentParser()
-
-parser.add_argument('features', type=str, help='Features generated from dump_data')
-parser.add_argument('data', type=str, help='Data generated from dump_data (offset by 5ms)')
-parser.add_argument('output', type=str, help='output .f32 feature file with replaced neural pitch')
-parser.add_argument('checkpoint', type=str, help='model checkpoint file')
-parser.add_argument('path_lpcnet_extractor', type=str, help='path to LPCNet extractor object file (generated on compilation)')
-parser.add_argument('--device', type=str, help='compute device',default = None,required = False)
-parser.add_argument('--replace_xcorr', type = bool, default = False, help='Replace LPCNet xcorr with updated one')
-
-args = parser.parse_args()
-
-import os
-
-from utils import stft, random_filter
-import subprocess
-import numpy as np
-import json
-import torch
-import tqdm
-
-from models import PitchDNNIF, PitchDNNXcorr, PitchDNN
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-if device is not None:
-    device = torch.device(args.device)
-
-# Loading the appropriate model
-checkpoint = torch.load(args.checkpoint, map_location='cpu')
-dict_params = checkpoint['config']
-
-if dict_params['data_format'] == 'if':
-    pitch_nn = PitchDNNIF(dict_params['freq_keep']*3, dict_params['gru_dim'], dict_params['output_dim'])
-elif dict_params['data_format'] == 'xcorr':
-    pitch_nn = PitchDNNXcorr(dict_params['xcorr_dim'], dict_params['gru_dim'], dict_params['output_dim'])
-else:
-    pitch_nn = PitchDNN(dict_params['freq_keep']*3, dict_params['xcorr_dim'], dict_params['gru_dim'], dict_params['output_dim'])
-
-pitch_nn.load_state_dict(checkpoint['state_dict'])
-pitch_nn = pitch_nn.to(device)
-
-N = dict_params['window_size']
-H = dict_params['hop_factor']
-freq_keep = dict_params['freq_keep']
-
-os.environ["OMP_NUM_THREADS"] = "16"
-
-
-def run_lpc(signal, lpcs, frame_length=160):
-    num_frames, lpc_order = lpcs.shape
-
-    prediction = np.concatenate(
-        [- np.convolve(signal[i * frame_length : (i + 1) * frame_length + lpc_order - 1], lpcs[i], mode='valid') for i in range(num_frames)]
-    )
-    error = signal[lpc_order :] - prediction
-
-    return prediction, error
-
-
-if __name__ == "__main__":
-    args = parser.parse_args()
-
-    features = np.memmap(args.features, dtype=np.float32,mode = 'r').reshape((-1, 36))
-    data     = np.memmap(args.data, dtype=np.int16,mode = 'r').reshape((-1, 2))
-
-    num_frames = features.shape[0]
-    feature_dim = features.shape[1]
-
-    assert feature_dim == 36
-
-    output  = np.memmap(args.output, dtype=np.float32, shape=(num_frames, feature_dim), mode='w+')
-    output[:, :36] = features
-
-    # lpc coefficients and signal
-    lpcs = features[:, 20:36]
-    sig = data[:, 1]
-
-    # parameters
-
-    # constants
-    pitch_min = 32
-    pitch_max = 256
-    lpc_order = 16
-    fs = 16000
-    frame_length = 160
-    overlap_frames = 100
-    chunk_size = 10000
-    history_length = frame_length * overlap_frames
-    history = np.zeros(history_length, dtype=np.int16)
-    pitch_position=18
-    xcorr_position=19
-    conf_position=36
-
-    num_frames = len(sig) // 160 - 1
-
-    frame_start = 0
-    frame_stop = min(frame_start + chunk_size, num_frames)
-    signal_start = 0
-    signal_stop = frame_stop * frame_length
-
-    niters = (num_frames - 1)//chunk_size
-    for i in tqdm.trange(niters):
-        if (frame_start > num_frames - 1):
-            break
-        chunk = np.concatenate((history, sig[signal_start:signal_stop]))
-        chunk_la = np.concatenate((history, sig[signal_start:signal_stop + 80]))
-
-        # Feature computation
-        spec = stft(x = np.concatenate([np.zeros(80),chunk_la/(2**15 - 1)]), w = 'boxcar', N = N, H = H).T
-        phase_diff = spec*np.conj(np.roll(spec,1,axis = -1))
-        phase_diff = phase_diff/(np.abs(phase_diff) + 1.0e-8)
-        idx_save = np.concatenate([np.arange(freq_keep),(N//2 + 1) + np.arange(freq_keep),2*(N//2 + 1) + np.arange(freq_keep)])
-        feature = np.concatenate([np.log(np.abs(spec) + 1.0e-8),np.real(phase_diff),np.imag(phase_diff)],axis = 0).T
-        feature_if = feature[:,idx_save]
-
-        data_temp = np.memmap('./temp_featcompute_' + dict_params['data_format'] + '_.raw', dtype=np.int16, shape=(chunk.shape[0]), mode='w+')
-        data_temp[:chunk.shape[0]] = chunk_la[80:].astype(np.int16)
-
-        subprocess.run([args.path_lpcnet_extractor, './temp_featcompute_' + dict_params['data_format'] + '_.raw', './temp_featcompute_xcorr_' + dict_params['data_format'] + '_.raw'])
-        feature_xcorr = np.flip(np.fromfile('./temp_featcompute_xcorr_' + dict_params['data_format'] + '_.raw', dtype='float32').reshape((-1,256),order = 'C'),axis = 1)
-        ones_zero_lag = np.expand_dims(np.ones(feature_xcorr.shape[0]),-1)
-        feature_xcorr = np.concatenate([ones_zero_lag,feature_xcorr],axis = -1)
-
-        os.remove('./temp_featcompute_' + dict_params['data_format'] + '_.raw')
-        os.remove('./temp_featcompute_xcorr_' + dict_params['data_format'] + '_.raw')
-
-        if dict_params['data_format'] == 'if':
-            feature = feature_if
-        elif dict_params['data_format'] == 'xcorr':
-            feature = feature_xcorr
-        else:
-            indmin = min(feature_if.shape[0],feature_xcorr.shape[0])
-            feature = np.concatenate([feature_xcorr[:indmin,:],feature_if[:indmin,:]],-1)
-
-        # Compute pitch with my model
-        model_cents = pitch_nn(torch.from_numpy(np.copy(np.expand_dims(feature,0))).float().to(device))
-        model_cents = 20*model_cents.argmax(dim=1).cpu().detach().squeeze().numpy()
-        frequency = 62.5*2**(model_cents/1200)
-
-        frequency  = frequency[overlap_frames : overlap_frames + frame_stop - frame_start]
-
-        # convert frequencies to periods
-        periods    = np.round(fs / frequency)
-
-        periods = np.clip(periods, pitch_min, pitch_max)
-
-        output[frame_start:frame_stop, pitch_position] = (periods - 100) / 50
-
-        frame_offset = (pitch_max + frame_length - 1) // frame_length
-        offset = frame_offset * frame_length
-        padding = lpc_order
-
-
-        if frame_start < frame_offset:
-            lpc_coeffs = np.concatenate((np.zeros((frame_offset - frame_start, lpc_order), dtype=np.float32), lpcs[:frame_stop]))
-        else:
-            lpc_coeffs = lpcs[frame_start - frame_offset : frame_stop]
-
-        pred, error = run_lpc(chunk[history_length - offset - padding :], lpc_coeffs, frame_length=frame_length)
-
-        xcorr = np.zeros(frame_stop - frame_start)
-        for i, p in enumerate(periods.astype(np.int16)):
-            if p > 0:
-                f1 = error[offset + i * frame_length : offset + (i + 1) * frame_length]
-                f2 = error[offset + i * frame_length - p : offset + (i + 1) * frame_length - p]
-                xcorr[i] = np.dot(f1, f2) / np.sqrt(np.dot(f1, f1) * np.dot(f2, f2) + 1e-6)
-
-        output[frame_start:frame_stop, xcorr_position] = xcorr - 0.5
-
-        # update buffers and indices
-        history = chunk[-history_length :]
-
-        frame_start += chunk_size
-        frame_stop += chunk_size
-        frame_stop = min(frame_stop, num_frames)
-
-        signal_start = frame_start * frame_length
-        signal_stop  = frame_stop  * frame_length

package/opus/dnn/torch/neural-pitch/ptdb_process.sh

@@ -1,34 +0,0 @@
-# Copy into PTDB root directory and run to combine all the male/female raw audio/references into below directories
-
-# Make folder for combined audio
-mkdir -p './combined_mic_16k/'
-# Make folder for combined pitch reference
-mkdir -p './combined_reference_f0/'
-
-# Resample Male Audio
-for i in ./MALE/MIC/**/*.wav; do
-j="$(basename "$i" .wav)"
-echo $j
-sox -r 48000 -b 16 -e signed-integer "$i" -r 16000 -b 16 -e signed-integer ./combined_mic_16k/$j.raw
-done
-
-# Resample Female Audio
-for i in ./FEMALE/MIC/**/*.wav; do
-j="$(basename "$i" .wav)"
-echo $j
-sox -r 48000 -b 16 -e signed-integer "$i" -r 16000 -b 16 -e signed-integer ./combined_mic_16k/$j.raw
-done
-
-# Shift Male reference pitch files
-for i in ./MALE/REF/**/*.f0; do
-j="$(basename "$i" .wav)"
-echo $j
-cp "$i" ./combined_reference_f0/
-done
-
-# Shift Female reference pitch files
-for i in ./FEMALE/REF/**/*.f0; do
-j="$(basename "$i" .wav)"
-echo $j
-cp "$i" ./combined_reference_f0/
-done

package/opus/dnn/torch/neural-pitch/run_crepe.py

@@ -1,72 +0,0 @@
-"""
-Perform Data Augmentation (Gain, Additive Noise, Random Filtering) on Input TTS Data
-1. Read in chunks and compute clean pitch first
-2. Then add in augmentation (Noise/Level/Response)
-    - Adds filtered noise from the "Demand" dataset, https://zenodo.org/record/1227121#.XRKKxYhKiUk
-    - When using the Demand Dataset, consider each channel as a possible noise input, and keep the first 4 minutes of noise for training
-3. Use this "augmented" audio for feature computation, and compute pitch using CREPE on the clean input
-
-Notes: To ensure consistency with the discovered CREPE offset, we do the following
-- We pad the input audio to the zero-centered CREPE estimator with 80 zeros
-- We pad the input audio to our feature computation with 160 zeros to center them
-"""
-
-import argparse
-parser = argparse.ArgumentParser()
-
-parser.add_argument('data', type=str, help='input raw audio data')
-parser.add_argument('output', type=str, help='output directory')
-parser.add_argument('--gpu-index', type=int, help='GPU index to use if multiple GPUs',default = 0,required = False)
-parser.add_argument('--chunk-size-frames', type=int, help='Number of frames to process at a time',default = 100000,required = False)
-
-args = parser.parse_args()
-
-import os
-os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu_index)
-
-import numpy as np
-import tqdm
-import crepe
-
-data = np.memmap(args.data, dtype=np.int16,mode = 'r')
-
-# list_features = []
-list_cents = []
-list_confidences = []
-
-min_period = 32
-max_period = 256
-f_ref = 16000/max_period
-chunk_size_frames = args.chunk_size_frames
-chunk_size = chunk_size_frames*160
-
-nb_chunks = (data.shape[0]+79)//chunk_size+1
-
-output_data = np.zeros((0,2),dtype='float32')
-
-for i in tqdm.trange(nb_chunks):
-    if i==0:
-        chunk = np.concatenate([np.zeros(80),data[:chunk_size-80]])
-    elif i==nb_chunks-1:
-        chunk = data[i*chunk_size-80:]
-    else:
-        chunk = data[i*chunk_size-80:(i+1)*chunk_size-80]
-    chunk = chunk/np.array(32767.,dtype='float32')
-
-    # Clean Pitch/Confidence Estimate
-    # Padding input to CREPE by 80 samples to ensure it aligns
-    _, pitch, confidence, _ = crepe.predict(chunk, 16000, center=True, viterbi=True,verbose=0)
-    pitch = pitch[:chunk_size_frames]
-    confidence = confidence[:chunk_size_frames]
-
-
-    # Filter out of range pitches/confidences
-    confidence[pitch < 16000/max_period] = 0
-    confidence[pitch > 16000/min_period] = 0
-    pitch = np.reshape(pitch, (-1, 1))
-    confidence = np.reshape(confidence, (-1, 1))
-    out = np.concatenate([pitch, confidence], axis=-1, dtype='float32')
-    output_data = np.concatenate([output_data, out], axis=0)
-
-
-output_data.tofile(args.output)