TurnMaster_processing/augment_taskmaster.py

import json
import math
import os
import csv
import random
from pathlib import Path
import re
import argparse
import soundfile as sf
import numpy as np
import torch
import torchaudio
from tqdm import tqdm
import pandas as pd
from whisper_normalizer.english import EnglishTextNormalizer
import re

# -------------------------
# Helpers
# -------------------------
def load_mono_resampled(path, sr):
    wav_np, fs = sf.read(path, always_2d=True)   # [T, C]
    wav = torch.from_numpy(wav_np).float().T     # [C, T]

    if wav.shape[0] > 1:
        wav = wav.mean(dim=0, keepdim=True)
    else:
        wav = wav[:1]

    if fs != sr:
        wav = torchaudio.functional.resample(wav, fs, sr)
        
    # Remove DC offsets
    wav = torchaudio.functional.highpass_biquad(wav, sample_rate=sr, cutoff_freq=20.0)

    peak = wav.abs().max(dim=1, keepdim=True).values.clamp_min(1e-8)
    wav = 0.95 * wav / peak                    # peak normalize to [-0.95, 0.95]
    return wav  # [1, T]

pattern = re.compile(r"\$(\d+(?:\.\d+)?)")

def transform_money(text: str) -> str:
    def repl(match):
        value = float(match.group(1))
        doubled = value * 2
        # Remove trailing .0 for integers
        if doubled.is_integer():
            doubled = int(doubled)
        return f"{doubled} dollars"
    return pattern.sub(repl, text)

def normalize_punct(text, english_normalizer):
    parts = re.split(r'\.{3}|[.!?;]', text)
    parts = [p.strip() for p in parts if p.strip()]
    normalized_text = ""
    for part in parts:
        norm_part = english_normalizer(part)
        normalized_text += norm_part + " , "
    normalized_text += " . "
    normalized_text = normalized_text.replace(" ,  . ", " . ")
    return normalized_text
        

def process_manifest(manifest_dir, wav_root, samples, args):
    manifest_csv = pd.read_csv(manifest_dir)
    wav_dirs = manifest_csv["audio_path"].values
    audio_id = manifest_csv["audio_id"].values 
    texts = manifest_csv["synthetic_text"].values
    conversation_ids = manifest_csv["conversation_id"].values
    utterance_indexes = manifest_csv["utterance_index"].values
    role = manifest_csv["speaker"].values
    split = manifest_csv["split"].values
    english_normalizer = EnglishTextNormalizer()
    for entry_idx in range(len(wav_dirs)):
        if role[entry_idx] == "user":
            result = {
                "wav_dir": f'{wav_root}/{wav_dirs[entry_idx]}',
                "text": texts[entry_idx],
                "dialog_id": conversation_ids[entry_idx],
                "turn_id": utterance_indexes[entry_idx],
                "split": split[entry_idx],
                "audio_id": audio_id[entry_idx]
            }
            
            if args.normalize_text:
                if args.keep_punct:
                    result['text'] = normalize_punct(result['text'], english_normalizer) #english_normalizer(result['text'])
                else:
                    result['text'] = english_normalizer(result['text'])
            
            if args.custom_dollar_normalisation:
                result['text'] = transform_money(result['text'])
                
            samples.append(result)

    return samples

def rms(x, eps=1e-12):
    return torch.sqrt(torch.mean(x**2) + eps)

def fit_noise_length(noise, target_len):
    n = noise.shape[1]
    if n == target_len:
        return noise
    elif n > target_len:
        start = random.randint(0, n - target_len)
        return noise[:, start:start + target_len]
    else:
        repeat = (target_len + n - 1) // n
        noise_rep = noise.repeat(1, repeat)
        return noise_rep[:, :target_len]

def mix_with_snr(clean, noise, snr_db):
    clean_rms = rms(clean)
    noise_rms = rms(noise)
    noise_rms_target = clean_rms / (10 ** (snr_db / 20))
    scale = noise_rms_target / (noise_rms + 1e-12)
    noisy = clean + scale * noise
    return torch.clamp(noisy, -1.0, 1.0)

def vad_labels_from_interval(
    num_samples: int,
    sr: int,
    speech_start: float,
    speech_end: float,
    intermediate_silences: list,
    frame_hop_s: float = 0.01,
    frame_len_s: float = 0.025,
) -> torch.Tensor:
    total_dur = num_samples / sr
    num_frames = int(math.ceil(total_dur / frame_hop_s))
    labels = torch.zeros(num_frames, dtype=torch.float32)
        
    for i in range(num_frames):
        center_t = i * frame_hop_s + 0.5 * frame_len_s
        is_intermediate_silence = False
        for silence in intermediate_silences:
            if silence[0] <= center_t < silence[1]:
                if silence[0] - speech_start - 0.032 < 0.001:
                    if labels[i] != 0.0:
                        labels[i] = 0.0
                    if labels[i-1] != 0.0:
                        labels[i-1] = 0.0
                    if labels[i-2] != 0.0:
                        labels[i-2] = 0.0
                    is_intermediate_silence = True
                    break
                else:
                    if i+1 < num_frames:
                        labels[i+1] = 3.0
                    labels[i] = 3.0

                    is_intermediate_silence = True
                    break
        if not is_intermediate_silence:
            if speech_start <= center_t < speech_end:
                labels[i] = 1.0
            elif center_t > speech_end:
                labels[i] = 2.0

    # Change intermediate silences followed by endpoint to endpoint
    for i in range(num_frames-2, -1, -1):
        if labels[i+1] == 0.0:
            labels[i] = 2.0
        if labels[i+1] == 2.0 and labels[i] == 3.0:
            labels[i] = 2.0
        elif labels[i] == 1.0:
            break
    
    # Remove speech less than 100ms before between intermediate silence E.P.
    labels = fix_prev_values(labels)
    
    # Change intermediate silences followed by endpoint to E.P. again
    for i in range(num_frames-2, -1, -1):
        if labels[i+1] == 0.0:
            labels[i] = 2.0
        if labels[i+1] == 2.0 and labels[i] == 3.0:
            labels[i] = 2.0
        elif labels[i] == 1.0:
            break
        
    labels = torch.cat((torch.zeros(1,), labels))
    labels = labels[:-1]
    eot_idx = torch.where(labels == 2.0)[0]
    start_eot_idx = eot_idx[0].item()
    return labels, start_eot_idx

# -------------------------
# Argparse
# -------------------------
def parse_args():
    parser = argparse.ArgumentParser(description="Augment Taskmaster with start / end silences and optional noise.")

    parser.add_argument("--target-sr", type=int, default=16000)
    parser.add_argument("--silence-min-start", type=float, default=0.0, help="Minimum silence duration (seconds) for start and end silences")
    parser.add_argument("--silence-max-start", type=float, default=0.0, help="Maximum silence duration (seconds) for start and end silences")
    parser.add_argument("--silence-min-end", type=float, default=0.0, help="Minimum silence duration (seconds) for start and end silences")
    parser.add_argument("--silence-max-end", type=float, default=3.0, help="Maximum silence duration (seconds) for start and end silences")
    parser.add_argument("--silence-insertion-min-s", type=float, default=0.05, help="Minimum silence duration (seconds) for silence insertions")
    parser.add_argument("--silence-insertion-max-s", type=float, default=2.0, help="Maximum silence duration (seconds) for silence insertions")
    parser.add_argument("--pause-per-second-ratio", type=float, default=0.7, help="Maximum ratio of silence per audio duration allowed. Ex if audio duration = 10s and --pause-per-second-ratio 0.5 the maximum of number of silences to be inserted is 5.")
    
    parser.add_argument("--lam", type=float, default=0.003, help="Lam for exponential silence duration sampling")
    parser.add_argument("--max-initial-silence-duration", type=float, default=1.5, help="Maximum silence duration (seconds) for silence insertions")
    
    parser.add_argument("--snr-min-db", type=float, default=10)
    parser.add_argument("--snr-max-db", type=float, default=21)
    parser.add_argument("--frame-hop-s", type=float, default=0.01 * 4)
    parser.add_argument("--frame-len-s", type=float, default=0.032 * 4)

    parser.add_argument("--normalize-text", action="store_true")
    parser.add_argument("--keep-punct", action="store_true")
    parser.add_argument("--custom-dollar-normalisation", action="store_true", help="replace $10 to 10 dollars")
    parser.add_argument("--silence-insertion", action="store_true")
    
    parser.add_argument("--VAD-hop-length", type=int, default=256, help="Hop length used by the energy based VAD for speech segmentation before silence insertion.")
    parser.add_argument("--VAD-frame-length", type=int, default=512, help="Frame length used by the energy based VAD for speech segmentation before silence insertion.")
    parser.add_argument("--VAD-energy-threshold", type=float, default=0.01, help="Energy threshold used by the energy based VAD for speech segmentation before silence insertion.")
    parser.add_argument("--VAD-min-silence-frames", type=int, default=3, help="Min silence frame used by the energy based VAD for speech segmentation before silence insertion.")

    parser.add_argument("--taskmaster-root-dir", type=str, required=True, help="The root leading to the manifest.csv and the audios.")
    parser.add_argument("--manifest-dir", type=str, required=True, help="The manifest to use to build the new TurnMaster version.")
    parser.add_argument("--aug-dataset-save-dir", type=str, required=True, help="The directory to save the dataset version.")
    
    parser.add_argument("--add-white-noise", action="store_true", help="Required only if SNR args are provided.")
    parser.add_argument("--add-bg-noise", action="store_true", help="Required only if SNR args are provided.")
    parser.add_argument("--input-noise-dir", type=str, default="/opt/marcel-c3/workdir/clws3842/datasets/musan/musan", help="Required only if SNR args are provided.")

    parser.add_argument(
        "--splits",
        nargs="+",
        default=["train", "dev", "test"],
        choices=["train", "dev", "test"],
        help="Which splits to process"
    )

    parser.add_argument("--seed", type=int, default=3265)

    return parser.parse_args()

def save_args_json(args, path="args.json"):
    path = Path(path)
    path.parent.mkdir(parents=True, exist_ok=True)
    with open(path, "w", encoding="utf-8") as f:
        json.dump(vars(args), f, indent=2, ensure_ascii=False)

def detect_silence_segments(
    waveform,
    frame_length=1024,
    hop_length=512,
    energy_threshold=0.01,
    min_silence_frames=3
):
    """
    Detect silence regions in an audio waveform using short-time energy.

    Args:
        waveform (np.ndarray): 1D audio signal, or 2D with shape (channels, samples) / (samples, channels).
        frame_length (int): Number of samples per frame.
        hop_length (int): Step size between frames.
        energy_threshold (float): Frames with RMS energy below this are considered silent.
        min_silence_frames (int): Minimum consecutive silent frames to keep.

    Returns:
        List[Tuple[int, int]]: List of (start_frame, end_frame) silence intervals (inclusive).
    """
    waveform = np.asarray(waveform)

    # Robustly convert to 1D mono
    if waveform.ndim == 2:
        # If (channels, samples), average over channels
        if waveform.shape[0] <= waveform.shape[1]:
            waveform = waveform.mean(axis=0)
        else:
            # If (samples, channels), average over channels
            waveform = waveform.mean(axis=1)
    elif waveform.ndim != 1:
        raise ValueError("waveform must be 1D or 2D")

    waveform = waveform.astype(np.float32, copy=False)

    n_samples = len(waveform)
    if n_samples < frame_length:
        return []

    # Number of complete frames
    n_frames = 1 + (n_samples - frame_length) // hop_length

    # Frame-wise RMS energy
    energies = np.empty(n_frames, dtype=np.float32)
    for i in range(n_frames):
        start = i * hop_length
        frame = waveform[start:start + frame_length]
        energies[i] = np.sqrt(np.mean(frame * frame) + 1e-12)

    # Silent mask
    silent = energies < energy_threshold

    # Group consecutive silent frames
    silence_segments = []
    in_segment = False
    seg_start = 0

    for i, is_silent in enumerate(silent):
        if is_silent and not in_segment:
            in_segment = True
            seg_start = i
        elif not is_silent and in_segment:
            seg_end = i - 1
            if (seg_end - seg_start + 1) >= min_silence_frames:
                silence_segments.append((seg_start, seg_end))
            in_segment = False

    # If segment reaches last frame
    if in_segment:
        seg_end = n_frames - 1
        if (seg_end - seg_start + 1) >= min_silence_frames:
            silence_segments.append((seg_start, seg_end))

    return silence_segments


def fix_prev_values(x: torch.Tensor, n: int = 3) -> torch.Tensor:
    """
    x: 1D tensor with values in [0, 3]
    n: number of values before first '2' to check
    
    Finds first index i where x[i] == 2.
    Checks slice x[max(0, i-n):i].
    If all are 1 -> keep unchanged.
    Otherwise sets that whole slice to 2.
    """
    x = x.clone()  # avoid modifying original tensor

    # Find first index where value == 2
    idx = torch.where(x == 2.0)[0]
    if idx.numel() == 0:
        return x  # no '2' found, nothing to do

    i = idx[0].item()
    start = max(0, i - n)

    prev_slice = x[start:i]
    if prev_slice.numel() > 0 and not torch.all(prev_slice == 1):
        x[start:i] = 2.0

    return x


def sample_truncated_exponential(
    lower=500,
    upper=1500,
    decay_rate=0.005
):
    """
    Return one sample from a truncated exponential distribution
    between lower and upper.
    """

    if lower >= upper:
        raise ValueError("lower must be less than upper")

    if decay_rate < 0:
        raise ValueError("decay_rate must be non-negative")

    if decay_rate == 0:
        return random.uniform(lower, upper)

    u = random.random()

    return lower - math.log(
        1 - u * (1 - math.exp(-decay_rate * (upper - lower)))
    ) / decay_rate


def add_silence(waveform, sr, args):
    """
    Insert random silent chunks at detected silence starts.

    Args:
        waveform (np.ndarray): 1D waveform (or 2D, will be converted to mono).
        sr (int): Sample rate used for insertion duration and timestamps.
        args: object with at least `target_sr` (optional; if missing, `sr` is used).

    Returns:
        waveform_torch (torch.Tensor): shape (1, num_samples)
        silence_infos (str): "start_sec|end_sec;..." for all detected silences
        intermediate_silences (list): List of [start_sec, end_sec] for all silences
    """
    # Ensure 1D mono float32
    waveform = np.asarray(waveform)
    if waveform.ndim == 2:
        if waveform.shape[0] <= waveform.shape[1]:
            waveform = waveform.mean(axis=0)
        else:
            waveform = waveform.mean(axis=1)
    elif waveform.ndim != 1:
        raise ValueError("waveform must be 1D or 2D")
    waveform = waveform.astype(np.float32, copy=False)
    
    frame_length = args.VAD_frame_length
    hop_length = args.VAD_hop_length
    
    silences = detect_silence_segments(
        waveform,
        frame_length=frame_length,
        hop_length=hop_length,
        energy_threshold=args.VAD_energy_threshold,
        min_silence_frames=args.VAD_min_silence_frames
    )
    
    num_frames_waveform = len(waveform)
    
    # Exclude segments touching first/last frame (correct unit: frames)
    if silences:
        n_frames = 1 + (num_frames_waveform - frame_length) // hop_length if num_frames_waveform >= frame_length else 0
    
    used_sr = getattr(args, "target_sr", sr)
    
    silence_infos = "["
    intermediate_silences = []
    
    if len(silences) > 0:
        silences_idx_correct = [x for x in range(len(silences)) if (silences[x][1] * hop_length / sr) - (silences[x][0] * hop_length / sr) < args.max_initial_silence_duration]
        max_sil_insertion = max(1, int(num_frames_waveform / sr * args.pause_per_second_ratio))
        
        rand_num_silence = np.random.randint(0, min(max_sil_insertion, len(silences_idx_correct) + 1))
        
        elongate_indices = set()
        if rand_num_silence > 0 and args.silence_insertion == True:
            idx = np.random.choice(len(silences_idx_correct), replace=False, size=rand_num_silence)
            elongate_indices = set(idx)
        
        silences_to_elongate = [(i, silences[i]) for i in elongate_indices 
                                if silences[i][0] != 0 and silences[i][1] != (n_frames - 1)]
        silences_to_elongate = sorted(silences_to_elongate, key=lambda x: x[1][0], reverse=False)
                
        added_duration = 0
        elongated_map = {}
        
        for silence_idx, silence in silences_to_elongate:
            # Calculate the original silence boundaries in samples
            silence_start_sample = silence[0] * hop_length
            silence_end_sample = (silence[1] + 1) * hop_length
            sample_silence_duration = silence_end_sample - silence_start_sample
            
            # Calculate insertion point: end of silence - 2 frames
            insert_sample = silence_end_sample - (2 * hop_length) + added_duration
            
            if args.lam > 0:
                # Generate exp random silence duration
                silence_duration = sample_truncated_exponential(
                    int(args.silence_insertion_min_s * 1000),
                    int(args.silence_insertion_max_s * 1000),
                    args.lam
                )
                silence_duration = int(silence_duration / 1000 * sr)
            else:
                # Generate uniform random silence duration
                silence_duration = int(np.random.randint(
                    sr * args.silence_insertion_min_s, 
                    sr * args.silence_insertion_max_s)
                )
            silence_insert = np.zeros((silence_duration,), dtype=waveform.dtype)
            
            # Insert at end - 2 frames of the silence
            waveform = np.insert(waveform, insert_sample, silence_insert)
            
            # ═══════════════════════════════════════════════════════════════
            # FIX: Store the original start sample for correct timestamp calculation
            # ═══════════════════════════════════════════════════════════════
            elongated_map[silence_idx] = (added_duration, silence_duration, sample_silence_duration, silence_start_sample)
            added_duration += silence_duration
        
        cumulative_added = 0
        for silence_idx in range(len(silences)):
            silence = silences[silence_idx]
            
            if silence_idx in elongated_map:
                # ═══════════════════════════════════════════════════════════════
                # FIX: Calculate timestamps correctly for elongated silences
                # ═══════════════════════════════════════════════════════════════
                # The silence now spans from its original start to its original end + inserted duration
                added_at_this_point, silence_duration, sample_silence_duration, silence_start_sample = elongated_map[silence_idx]
                
                # Start remains at the original silence start (adjusted for previous insertions)
                start_sample = silence_start_sample + added_at_this_point
                # End is original end + inserted silence duration (adjusted for previous insertions)
                end_sample = start_sample + sample_silence_duration + silence_duration
                
                start_t = start_sample / used_sr
                end_t = end_sample / used_sr
                
                silence_infos += f"{start_t:.4f}|{end_t:.4f};"
                intermediate_silences.append([start_t, end_t])
                
                cumulative_added = added_at_this_point + silence_duration
            else:
                # Non-elongated silences
                start_sample = silence[0] * hop_length + cumulative_added
                end_sample = (silence[1] + 1) * hop_length + cumulative_added
                
                start_t = start_sample / used_sr
                end_t = end_sample / used_sr
                
                silence_infos += f"{start_t:.4f}|{end_t:.4f};"
                intermediate_silences.append([start_t, end_t])
    
    silence_infos += "]"
    
    waveform = torch.from_numpy(waveform.astype(np.float32, copy=False)).unsqueeze(0)
    return waveform, silence_infos, intermediate_silences



def add_silence_deprecated(waveform, sr, args):
    """
    Insert random silent chunks at detected silence starts.

    Args:
        waveform (np.ndarray): 1D waveform (or 2D, will be converted to mono).
        sr (int): Sample rate used for insertion duration and timestamps.
        args: object with at least `target_sr` (optional; if missing, `sr` is used).

    Returns:
        waveform_torch (torch.Tensor): shape (1, num_samples)
        silence_infos (str): "start_sec-end_sec$..." for inserted chunks
    """
    # Ensure 1D mono float32
    waveform = np.asarray(waveform)
    if waveform.ndim == 2:
        if waveform.shape[0] <= waveform.shape[1]:
            waveform = waveform.mean(axis=0)
        else:
            waveform = waveform.mean(axis=1)
    elif waveform.ndim != 1:
        raise ValueError("waveform must be 1D or 2D")
    waveform = waveform.astype(np.float32, copy=False)
    
    frame_length = args.VAD_frame_length
    hop_length = args.VAD_hop_length
    
    silences = detect_silence_segments(
        waveform,
        frame_length=frame_length,
        hop_length=hop_length,
        energy_threshold=args.VAD_energy_threshold,
        min_silence_frames=args.VAD_min_silence_frames
    )
    
    # Exclude segments touching first/last frame (correct unit: frames)
    num_frames_waveform = len(waveform)
    if silences:
        n_frames = 1 + (num_frames_waveform - frame_length) // hop_length if num_frames_waveform >= frame_length else 0
    
    used_sr = getattr(args, "target_sr", sr)
    print(len(silences))
    
    silence_infos = "["
    intermediate_silences = []
    if len(silences) > 0:
        pause_per_second_ration = 0.75
        max_sil_insertion = max(1, int(num_frames_waveform / sr * pause_per_second_ration))
        print(max_sil_insertion, num_frames_waveform / sr)
        rand_num_silence = np.random.randint(0, min(max_sil_insertion, len(silences) + 1))
        if rand_num_silence > 0 and args.silence_insertion == True:
            idx = np.random.choice(len(silences), replace=False, size=rand_num_silence)
            random_silences = [silences[i] for i in idx]
            # descending so earlier insertions don't shift later indices
            random_silences = sorted(random_silences, key=lambda x: x[0], reverse=True)
            added_duration = 0
            for silence_idx in range(len(silences)):
                if silence_idx in idx and silences[silence_idx][0] != 0 and silences[silence_idx][1] != (n_frames - 1):
                    # Convert frame index -> sample index
                    silence = silences[silence_idx]
                    insert_sample = (silence[0] + 2) * hop_length + added_duration # +2 to account for frame length
                    sample_silence_duration = (silence[1] + 1) * hop_length - silence[0] * hop_length # +1 to account for strict exclusion

                    silence_duration = int(np.random.randint(sr * args.silence_insertion_min_s, sr * args.silence_insertion_max_s))
                    silence_insert = np.zeros((silence_duration,), dtype=waveform.dtype)

                    waveform = np.insert(waveform, insert_sample, silence_insert)

                    start_t = insert_sample / used_sr
                    end_t = (insert_sample + silence_duration) / used_sr
                    silence_infos += f"{start_t:.6f}|{end_t:.6f};"
                    intermediate_silences.append([insert_sample, (insert_sample + silence_duration + sample_silence_duration)])
                    added_duration += silence_duration
                else:
                    start_t, end_t = (silences[silence_idx][0] + 2) * hop_length + added_duration, (silences[silence_idx][1] + 2) * hop_length + added_duration
                    intermediate_silences.append([start_t, end_t])
        else:
            for silence_idx in range(len(silences)):
                start_t, end_t = (silences[silence_idx][0] + 2) * hop_length, (silences[silence_idx][1] + 2) * hop_length
                intermediate_silences.append([start_t, end_t])
                    
    intermediate_silences = [[x[0] / used_sr, x[1] / used_sr] for x in intermediate_silences]
    silence_infos += "]"

    waveform = torch.from_numpy(waveform.astype(np.float32, copy=False)).unsqueeze(0)
    return waveform, silence_infos, intermediate_silences


def is_sample_in_split(split, sample_split):
    if split == "train":
        if sample_split == "train":
            return True
        else:
            False
    elif split == "dev":
        if sample_split == "dev":
            return True
        else:
            False
            
    elif split == "test":
        if sample_split == "test":
            return True
        else:
            False
    else:
        raise(f"{split} does not exist in the list of dataset splits to process")

def main():
    print("Starting dataset augmentation.")
    args = parse_args()
    save_args_json(args, f'{args.aug_dataset_save_dir}/run_config.json')
    
    os.makedirs(f'{args.aug_dataset_save_dir}/figs', exist_ok=True)
    
    if args.seed is not None:
        random.seed(args.seed)
        np.random.seed(args.seed)
        torch.manual_seed(args.seed)

    if (args.snr_min_db is None) ^ (args.snr_max_db is None):
        raise ValueError("Provide both --snr-min-db and --snr-max-db, or neither.")

    for split in args.splits:

        out_audio_dir_tts = f'{args.aug_dataset_save_dir}/{split}/wav'
        out_vad_dir_tts = f'{args.aug_dataset_save_dir}/{split}/vad_labels'
        out_csv_path = f'{args.aug_dataset_save_dir}/{split}.csv'

        os.makedirs(out_audio_dir_tts, exist_ok=True)
        os.makedirs(out_vad_dir_tts, exist_ok=True)
        os.makedirs(Path(out_csv_path).parent, exist_ok=True)

        noise_files = []
        use_noise = args.add_bg_noise
        if use_noise:
            noise_files = sorted([
                str(p) for p in Path(args.input_noise_dir).glob("**/*")
                if p.suffix.lower() in [".wav", ".flac", ".mp3", ".ogg"]
                and "speech" not in str(p)
            ])
            if len(noise_files) == 0:
                raise RuntimeError("No noise files found.")

        speech_files = []
        manifest_dir = f'{args.manifest_dir}'
        speech_files = process_manifest(manifest_dir, args.taskmaster_root_dir, speech_files, args)

        rows = []
        for i, speech_sample in enumerate(tqdm(speech_files, desc=f"Processing {split}", unit="file")):
            if is_sample_in_split(split, speech_sample["split"]):
                speech_path = speech_sample["wav_dir"]
                base = Path(speech_path).stem
                out_audio_path = os.path.join(out_audio_dir_tts, f"{i:06d}_aug_{base}.wav")

                if os.path.exists(out_audio_path):
                    print("already exist")
                    continue

                speech = load_mono_resampled(speech_path, args.target_sr)
                speech, silence_infos, intermediate_silences = add_silence(speech, args.target_sr, args)
                
                T_speech = speech.shape[1]

                start_sil_s = random.uniform(args.silence_min_start, args.silence_max_start)
                end_sil_s = random.uniform(args.silence_min_end, args.silence_max_end)
                intermediate_silences = [[intermediate_silences[x][0] + start_sil_s, intermediate_silences[x][1] + start_sil_s] for x in range(len(intermediate_silences))]

                T_start = int(round(start_sil_s * args.target_sr))
                T_end = int(round(end_sil_s * args.target_sr))

                start_sil = torch.zeros((1, T_start), dtype=speech.dtype)
                end_sil = torch.zeros((1, T_end), dtype=speech.dtype)

                clean_aug = torch.cat([start_sil, speech, end_sil], dim=1)
                T_total = clean_aug.shape[1]

                vad_label, start_eot_idx = vad_labels_from_interval(
                    num_samples=T_total,
                    sr=args.target_sr,
                    speech_start=T_start / args.target_sr,
                    speech_end=(T_start + T_speech) / args.target_sr,
                    frame_hop_s=args.frame_hop_s,
                    frame_len_s=args.frame_len_s,
                    intermediate_silences=intermediate_silences,
                )
                
                is_syntethic = 1 if "tts" in speech_path or "train" in speech_path else 0

                base = Path(speech_path).stem
                out_audio_path = os.path.join(out_audio_dir_tts, f"aug_{i:06d}_{base}.wav")
                out_audio_noise_path = os.path.join(out_audio_dir_tts, f"aug_{i:06d}_{base}_noise.wav")
                out_vad_path = os.path.join(out_vad_dir_tts, f"aug_{i:06d}_{base}_vad.pt")


                noisy_aug = clean_aug.clone()
                noise_path = None
                if args.add_bg_noise and split != "train":
                    noise_path = random.choice(noise_files)
                    noise = load_mono_resampled(noise_path, args.target_sr)
                    noise = fit_noise_length(noise, T_total)

                    snr_db = random.uniform(args.snr_min_db, args.snr_max_db)
                    noisy_aug = mix_with_snr(noisy_aug, noise, snr_db)
                    
                if args.add_white_noise and split != "train":

                    snr_db = random.uniform(args.snr_min_db, args.snr_max_db)
                    white = torch.randn_like(clean_aug)
                    
                    noisy_aug = mix_with_snr(clean_aug, white, snr_db)
                                
                if args.add_white_noise or args.add_bg_noise:
                    if split != "train":
                        noisy_np = noisy_aug.squeeze(0).cpu().numpy().astype(np.float32)
                        sf.write(out_audio_noise_path, noisy_np, args.target_sr)
                        
                        rows.append({
                            "ID": f"aug_{i:06d}_{base}_noise",
                            "orig_speech_path": speech_path,
                            "noise_path": noise_path,
                            "wav": out_audio_noise_path,
                            "vad": out_vad_path,
                            "sample_rate": args.target_sr,
                            "speech_num_samples": T_speech,
                            "start_eot": start_eot_idx,
                            "start_eot_time": start_eot_idx * 0.04,
                            "start_silence_s": start_sil_s,
                            "end_silence_s": end_sil_s,
                            "start_silence_samples": T_start,
                            "end_silence_samples": T_end,
                            "total_num_samples": T_total,
                            "duration": T_total / args.target_sr,
                            "snr_db": snr_db,
                            "speech_start_sample": T_start,
                            "speech_end_sample_exclusive": T_start + T_speech,
                            "wrd": speech_sample["text"],
                            "dialog_id": speech_sample["dialog_id"],
                            "turn_id": speech_sample["turn_id"],
                            "split": speech_sample["split"],
                            "audio_id": speech_sample["audio_id"],
                            "is_syntethic": is_syntethic,
                            "silence_infos": silence_infos,
                            "white_noise": args.add_white_noise,
                            "bg_noise": args.add_bg_noise
                        })
                
                noise_path = None
                snr_db = None
                clean_aug_np = clean_aug.squeeze(0).cpu().numpy().astype(np.float32)
                sf.write(out_audio_path, clean_aug_np, args.target_sr)
                rows.append({
                    "ID": f"aug_{i:06d}_{base}",
                    "orig_speech_path": speech_path,
                    "noise_path": noise_path,
                    "wav": out_audio_path,
                    "vad": out_vad_path,
                    "sample_rate": args.target_sr,
                    "speech_num_samples": T_speech,
                    "start_eot": start_eot_idx,
                    "start_eot_time": start_eot_idx * 0.04,
                    "start_silence_s": start_sil_s,
                    "end_silence_s": end_sil_s,
                    "start_silence_samples": T_start,
                    "end_silence_samples": T_end,
                    "total_num_samples": T_total,
                    "duration": T_total / args.target_sr,
                    "snr_db": None,
                    "speech_start_sample": T_start,
                    "speech_end_sample_exclusive": T_start + T_speech,
                    "wrd": speech_sample["text"],
                    "dialog_id": speech_sample["dialog_id"],
                    "turn_id": speech_sample["turn_id"],
                    "split": speech_sample["split"],
                    "audio_id": speech_sample["audio_id"],
                    "is_syntethic": is_syntethic,
                    "silence_infos": silence_infos,
                    "white_noise": False,
                    "bg_noise": False
                })

                torch.save(vad_label, out_vad_path)

        fieldnames = list(rows[0].keys()) if rows else []
        with open(out_csv_path, "w", newline="", encoding="utf-8") as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(rows)

        print(f"[{split}] Done. Processed {len(rows)} files.")
        print(f"[{split}] Metadata CSV: {out_csv_path}")
    

if __name__ == "__main__":
    main()