convert.py

# -*- coding: utf-8 -*-
import os
import shutil
import re
from pypinyin import pinyin, Style
from textgrid import TextGrid, IntervalTier, Interval
import codecs
from collections import defaultdict
# --- Add tqdm ---
# pip install tqdm
from tqdm import tqdm

# --- Configuration ---
SOURCE_DATASET_DIR = r"D:\DiffSingerDatasets\m4singer"
OUTPUT_DATASET_DIR = r"D:\DiffSingerDatasets\m4singer_processed"
OPENCPOP_DICT_PATH = r"D:\DiffSingerDatasets\SOFA\dictionary\opencpop-extension.txt"
CREATE_OUTPUT_DIR_IF_NOT_EXISTS = True
TIME_TOLERANCE = 0.015 # Tolerance for matching interval boundaries
INITIAL_PHONE_SPLIT_FRACTION = 0.2 # Fraction for initial phonemes when splitting

# --- Phoneme Normalization/Simplification Maps ---
# Map from common variations FOUND in TextGrids TO potential TARGET phonemes in the Dictionary
# Focuses on FINALS or single-unit TG phonemes
TEXTGRID_TO_DICT_SIMPLIFY_MAP = {
    # Vowel i variations
    'i': ['i', 'ir', 'i0'],
    # Finals involving i/u glides in TG vs Dict
    'iou': ['iu', 'ou', 'o'], # TG iou -> Dict iu/ou or just o (for yo)
    'uei': ['ui', 'ei', 'uai'],# TG uei -> Dict ui/ei or huai?
    'uen': ['un', 'en', 'vn'], # TG uen -> Dict un/en or qun?
    # ü variations (v in dict)
    'v': ['v'],
    'u': ['u','v'],        # TG u -> Dict u OR v (for qu, ju, xu, yu)
    've': ['ve'],
    'van': ['van','uan'],   # TG van -> Dict van OR wan
    'vn': ['vn', 'un'],    # TG vn -> Dict vn or uen? (less likely)
    # ie/ian variations
    'ie': ['ie', 'E'],
    'ian': ['ian', 'En'],
    # Finals involving w glide
    'ua': ['a', 'ua'],
    'uai': ['ai', 'uai'],
    'uan': ['an', 'uan', 'van'], # TG uan -> Dict an/uan OR yuan
    'uang': ['ang', 'uang'],
    'uo': ['o', 'uo'],
    # Finals involving y glide
    'ia': ['a', 'ia'],
    'iao': ['ao', 'iao'],
    'iang': ['ang', 'iang'],
    'iong': ['ong', 'iong'],
    # Other finals
    'ueng': ['ueng', 'ong'],
    # Base finals for identity mapping
    'a': ['a'], 'o': ['o'], 'e': ['e', 'E'], 'ai': ['ai'], 'ei': ['ei'],
    'ao': ['ao'], 'ou': ['ou'], 'an': ['an'], 'en': ['en'], 'ang': ['ang'],
    'eng': ['eng'], 'ong': ['ong'], 'in': ['in'], 'un': ['un'], 'ui': ['ui'],
    'iu': ['iu'], 'ir': ['ir'], 'i0': ['i0'],
}
# Reverse map (Dictionary phoneme -> potential TextGrid phonemes)
DICT_TO_TEXTGRID_SIMPLIFY_MAP = defaultdict(list)

# --- Helper Functions ---

def parse_opencpop_dict(dict_path):
    """Parses the dictionary, returns map and populates reverse map."""
    pinyin_to_phonemes = {}
    all_dict_phonemes = set()
    try:
        with codecs.open(dict_path, 'r', encoding='utf-8') as f: raw_lines = f.readlines()
    except UnicodeDecodeError:
        try:
            with codecs.open(dict_path, 'r', encoding='gbk') as f: raw_lines = f.readlines()
            print("Info: Dictionary file read as GBK (UTF-8 failed).")
        except Exception as e_inner: print(f"Error reading dictionary {dict_path}: {e_inner}"); return None, None
    except FileNotFoundError: print(f"Error: Dictionary file not found at {dict_path}"); return None, None
    except Exception as e: print(f"Error reading dictionary {dict_path}: {e}"); return None, None

    for line in raw_lines:
        line = line.strip()
        if not line or '\t' not in line: continue
        parts = line.split('\t', 1)
        pinyin_key = parts[0].strip(); phonemes_str = parts[1].strip()
        phonemes = [ph for ph in phonemes_str.split(' ') if ph]
        if pinyin_key and phonemes:
            pinyin_to_phonemes[pinyin_key] = phonemes
            all_dict_phonemes.update(phonemes)

    if 'AP' not in pinyin_to_phonemes: pinyin_to_phonemes['AP'] = ['AP']; all_dict_phonemes.add('AP')
    if 'SP' not in pinyin_to_phonemes: pinyin_to_phonemes['SP'] = ['SP']; all_dict_phonemes.add('SP')

    # --- Populate DICT_TO_TEXTGRID_SIMPLIFY_MAP ---
    DICT_TO_TEXTGRID_SIMPLIFY_MAP.clear()
    mapped_dict_phonemes = set()
    for tg_form, dict_forms in TEXTGRID_TO_DICT_SIMPLIFY_MAP.items():
        for dict_form in dict_forms:
             DICT_TO_TEXTGRID_SIMPLIFY_MAP[dict_form].append(tg_form)
             mapped_dict_phonemes.add(dict_form)
    for ph in all_dict_phonemes: # Identity mapping
        if ph not in mapped_dict_phonemes:
            DICT_TO_TEXTGRID_SIMPLIFY_MAP[ph].append(ph)

    return pinyin_to_phonemes, all_dict_phonemes

def get_song_pinyin_name(name):
    """Converts a song name to a safe pinyin filename."""
    try:
        contains_chinese = any('\u4e00' <= char <= '\u9fff' for char in name)
        if not contains_chinese:
             safe_name = name.lower().strip()
             safe_name = re.sub(r'\s+', '_', safe_name); safe_name = re.sub(r'[^a-z0-9_]+', '', safe_name)
             safe_name = re.sub(r'_+', '_', safe_name).strip('_'); return safe_name if safe_name else "unknown_song"
        pinyin_list = pinyin(name, style=Style.NORMAL, errors='ignore')
        if not pinyin_list: raise ValueError("pypinyin returned empty list or failed")
        flat_pinyin = "_".join([item[0] for item in pinyin_list if item and item[0]])
        safe_name = re.sub(r'[^\w_]+', '', flat_pinyin).lower()
        safe_name = re.sub(r'_+', '_', safe_name).strip('_'); return safe_name if safe_name else "unknown_song"
    except Exception as e:
        print(f"Info: Could not convert '{name}' to pinyin ({e}). Using fallback cleaning.")
        safe_name = re.sub(r'[^\w]+', '_', name).strip('_').lower(); return safe_name if safe_name else "unknown_song"

def clean_special_symbols(text):
    """Removes < > brackets."""
    if isinstance(text, str) and text.startswith('<') and text.endswith('>'): return text[1:-1]
    return text

def get_phoneme_intervals_for_char(char_interval, phone_tier, tolerance):
    """Finds the sequence of original phone INTERVALS corresponding to the char_interval."""
    char_mark_cleaned = clean_special_symbols(char_interval.mark)
    if char_mark_cleaned in ['AP', 'SP']:
        found_interval = None; min_diff = float('inf')
        for phn_interval in phone_tier:
            time_diff = abs(phn_interval.minTime - char_interval.minTime) + abs(phn_interval.maxTime - char_interval.maxTime)
            mark_match = clean_special_symbols(phn_interval.mark) == char_mark_cleaned
            if time_diff < tolerance and mark_match:
                 if time_diff < min_diff: found_interval = phn_interval; min_diff = time_diff
        if found_interval: return [found_interval]
        else: print(f"Warning: No phone interval found for {char_mark_cleaned} char interval [{char_interval.minTime:.3f}-{char_interval.maxTime:.3f}]."); return None

    start_phone_idx, end_phone_idx = -1, -1
    min_start_diff, min_end_diff = float('inf'), float('inf')
    for i, phn_interval in enumerate(phone_tier):
        diff = abs(phn_interval.minTime - char_interval.minTime)
        if diff < tolerance and diff < min_start_diff: min_start_diff = diff; start_phone_idx = i
    if start_phone_idx != -1:
        search_start_index = start_phone_idx; max_expected_end_time = char_interval.maxTime + tolerance * 5
        for i in range(search_start_index, len(phone_tier)):
            phn_interval = phone_tier[i]
            if phn_interval.minTime > char_interval.maxTime + tolerance: break
            if phn_interval.maxTime > max_expected_end_time and end_phone_idx != -1: break
            diff = abs(phn_interval.maxTime - char_interval.maxTime)
            if diff < tolerance:
                if diff < min_end_diff: min_end_diff = diff; end_phone_idx = i
            elif end_phone_idx == -1 and diff < tolerance * 2:
                 if diff < min_end_diff: min_end_diff = diff; end_phone_idx = i
    if start_phone_idx != -1 and end_phone_idx != -1 and end_phone_idx >= start_phone_idx:
        intervals = [phone_tier[i] for i in range(start_phone_idx, end_phone_idx + 1)]
        non_sil_intervals = [iv for iv in intervals if clean_special_symbols(iv.mark) not in ['AP', 'SP', ''] and iv.mark and iv.mark.strip()]
        if non_sil_intervals: return non_sil_intervals
        elif intervals: print(f"Warning: Found time range for char '{char_interval.mark}' but only silence/empty phones within. [{char_interval.minTime:.3f}-{char_interval.maxTime:.3f}]"); return None
        else: return None
    else: print(f"Warning: Could not determine phone interval sequence for char '{char_interval.mark}' interval [{char_interval.minTime:.3f}-{char_interval.maxTime:.3f}]. (Start diff: {min_start_diff:.4f}, End diff: {min_end_diff:.4f})."); return None


def fuzzy_match_sequences(found_phones, expected_phones):
    """More robust fuzzy matching based on specific patterns."""
    if not found_phones or not expected_phones: return False
    if found_phones == expected_phones: return True

    f_str = "".join(found_phones)
    e_str = "".join(expected_phones)
    if f_str == e_str: return True

    if len(expected_phones) == 2 and expected_phones[0] in ['y', 'w'] and len(found_phones) == 1:
        expected_final = expected_phones[1]; found_final_tg = found_phones[0]
        if found_final_tg in DICT_TO_TEXTGRID_SIMPLIFY_MAP.get(expected_final, []): return True

    if len(expected_phones) == 1 and len(found_phones) == 2 and found_phones[0] in ['y', 'w']:
        expected_final = expected_phones[0]; found_final_tg = found_phones[1]
        if found_final_tg in DICT_TO_TEXTGRID_SIMPLIFY_MAP.get(expected_final, []): return True

    if len(found_phones) == len(expected_phones):
        match = True; initial = expected_phones[0] if len(expected_phones) > 0 else None
        for i in range(len(found_phones)):
            f_ph, e_ph = found_phones[i], expected_phones[i]
            possible_tg_forms = DICT_TO_TEXTGRID_SIMPLIFY_MAP.get(e_ph, [e_ph])
            if f_ph == e_ph or f_ph in possible_tg_forms: continue
            if e_ph == 'v' and f_ph == 'u' and initial in 'jqxy': continue
            if e_ph == 'van' and f_ph == 'uan' and initial in 'jqxy': continue
            if e_ph == 'vn' and f_ph == 'un' and initial in 'jqxy': continue
            if e_ph == 'uai' and f_ph == 'uei' and initial == 'h': continue
            if e_ph == 'ui' and f_ph == 'uei' and initial != 'h': continue
            if e_ph == 'iang' and f_ph == 'ang' and initial == 'x': continue
            match = False; break
        if match: return True

    return False

def get_correct_pinyin_and_map(char_mark, original_phone_intervals, pinyin_phoneme_map):
    """Determines best pinyin, handling '嗯' and direct joined check."""
    cleaned_char = clean_special_symbols(char_mark)
    if not cleaned_char or cleaned_char.isspace(): return cleaned_char, None
    if cleaned_char in ['AP', 'SP']: return cleaned_char, [cleaned_char]

    try: possible_pinyins_raw = pinyin(cleaned_char, style=Style.NORMAL, heteronym=True)[0]
    except Exception as e: print(f"Error getting pinyin for '{cleaned_char}': {e}."); return "?", None

    possible_pinyins = []
    if cleaned_char == '嗯':
        for p in possible_pinyins_raw:
            if p == 'n': possible_pinyins.append('en')
            elif p == 'ng': possible_pinyins.append('eng')
            else: possible_pinyins.append(p)
        if not possible_pinyins: possible_pinyins = ['en']
    else: possible_pinyins = possible_pinyins_raw

    if original_phone_intervals is None:
        chosen_pinyin = possible_pinyins[0]
        print(f"Warning: Defaulting pinyin '{cleaned_char}'->'{chosen_pinyin}' due to phone mapping error.")
        target_phones = pinyin_phoneme_map.get(chosen_pinyin)
        if target_phones is None: print(f"Error: Default pinyin '{chosen_pinyin}' for char '{cleaned_char}' not in dictionary!")
        return chosen_pinyin, target_phones

    found_phones_clean = [clean_special_symbols(iv.mark) for iv in original_phone_intervals]
    found_phones_str = " ".join(found_phones_clean)
    joined_found_phones = "".join(found_phones_clean)

    best_match_pinyin = None; match_type = "No Match"

    if joined_found_phones in pinyin_phoneme_map: # Direct joined check first
         best_match_pinyin = joined_found_phones; match_type = "Direct Joined"

    if match_type == "No Match": # Exact sequence check
        for pyn in possible_pinyins:
            if pyn in pinyin_phoneme_map:
                if " ".join(pinyin_phoneme_map[pyn]) == found_phones_str:
                    best_match_pinyin = pyn; match_type = "Exact"; break

    if match_type == "No Match": # Fuzzy sequence check
        fuzzy_matches = []
        for pyn in possible_pinyins:
            if pyn in pinyin_phoneme_map:
                if fuzzy_match_sequences(found_phones_clean, pinyin_phoneme_map[pyn]): fuzzy_matches.append(pyn)
        if len(fuzzy_matches) == 1: best_match_pinyin = fuzzy_matches[0]; match_type = "Fuzzy"
        elif len(fuzzy_matches) > 1: print(f"Warning: Ambiguous fuzzy match for '{cleaned_char}' ('{found_phones_str}'). Matches: {fuzzy_matches}. Defaulting."); match_type = "Default"; best_match_pinyin = possible_pinyins[0]
        else: match_type = "Default"; best_match_pinyin = possible_pinyins[0]

    chosen_pinyin = best_match_pinyin if best_match_pinyin else possible_pinyins[0]
    if cleaned_char == '嗯': # Ensure n/ng aren't chosen if en/eng exist
        if chosen_pinyin == 'n' and 'en' in pinyin_phoneme_map: chosen_pinyin = 'en'
        elif chosen_pinyin == 'ng' and 'eng' in pinyin_phoneme_map: chosen_pinyin = 'eng'

    if match_type == "Default":
        expected_details = {p: pinyin_phoneme_map.get(p, ["Not in Dict"]) for p in possible_pinyins}
        warning_msg = f"Warning: No reliable match for phonemes '{found_phones_str}' (derived for char '{cleaned_char}'). Possible pinyins: {possible_pinyins}. "
        warning_msg += ", ".join([f"Expected for '{p}': {det}" for p, det in expected_details.items()]) + "."
        warning_msg += f" Defaulting to pinyin: {chosen_pinyin}"
        print(warning_msg)

    target_phonemes = pinyin_phoneme_map.get(chosen_pinyin)
    if target_phonemes is None:
        print(f"Error: Chosen pinyin '{chosen_pinyin}' for char '{cleaned_char}' not in dictionary!")
        if cleaned_char == '嗯':
             if 'en' in pinyin_phoneme_map: chosen_pinyin, target_phonemes = 'en', pinyin_phoneme_map['en']
             elif 'eng' in pinyin_phoneme_map: chosen_pinyin, target_phonemes = 'eng', pinyin_phoneme_map['eng']

    return chosen_pinyin, target_phonemes


def process_textgrid_file(tg_path, pinyin_phoneme_map, tolerance, split_fraction):
    """Processes a single TextGrid file with duration splitting."""
    try: tg = TextGrid.fromFile(tg_path)
    except Exception as e: print(f"Error reading TG {tg_path}: {e}"); return None
    if len(tg.tiers) < 2: print(f"Warning: TG {tg_path} has < 2 tiers."); return None

    original_word_tier, original_phone_tier = None, None
    tier_names = [t.name.lower() if t.name else "" for t in tg.tiers]
    try:
        word_indices = [i for i, name in enumerate(tier_names) if name and ("word" in name or "hanzi" in name or "char" in name)]
        phone_indices = [i for i, name in enumerate(tier_names) if name and ("phone" in name or "syllable" in name or "phoneme" in name or "pinyin" in name)]
        if word_indices: original_word_tier = tg.tiers[word_indices[0]]
        if phone_indices: original_phone_tier = tg.tiers[phone_indices[0]]
    except Exception: pass
    if original_word_tier is None: original_word_tier = tg.tiers[0]
    if original_phone_tier is None:
        if len(tg.tiers) > 1: original_phone_tier = tg.tiers[1]
        else: print(f"Error: Cannot identify phone tier in {tg_path}."); return None

    new_word_tier = IntervalTier(name="words", minTime=tg.minTime, maxTime=tg.maxTime)
    new_phone_tier = IntervalTier(name="phones", minTime=tg.minTime, maxTime=tg.maxTime)
    last_word_max_time = tg.minTime; last_phone_max_time = tg.minTime

    for word_interval in original_word_tier:
        if word_interval.minTime > last_word_max_time + tolerance: new_word_tier.addInterval(Interval(last_word_max_time, word_interval.minTime, ""))
        if word_interval.minTime > last_phone_max_time + tolerance: new_phone_tier.addInterval(Interval(last_phone_max_time, word_interval.minTime, ""))
        if not word_interval.mark and word_interval.maxTime > word_interval.minTime:
            new_word_tier.addInterval(Interval(word_interval.minTime, word_interval.maxTime, ""))
            new_phone_tier.addInterval(Interval(word_interval.minTime, word_interval.maxTime, ""))
            last_word_max_time = max(last_word_max_time, word_interval.maxTime); last_phone_max_time = max(last_phone_max_time, word_interval.maxTime)
            continue
        elif not word_interval.mark or word_interval.maxTime <= word_interval.minTime: continue

        original_phone_intervals = get_phoneme_intervals_for_char(word_interval, original_phone_tier, tolerance)
        chosen_pinyin, target_phonemes = get_correct_pinyin_and_map(word_interval.mark, original_phone_intervals, pinyin_phoneme_map)

        new_word_tier.addInterval(Interval(word_interval.minTime, word_interval.maxTime, chosen_pinyin))
        last_word_max_time = max(last_word_max_time, word_interval.maxTime)

        if target_phonemes and original_phone_intervals:
            n_target, n_orig = len(target_phonemes), len(original_phone_intervals)
            if n_target == n_orig: # Case 1: Match
                for i in range(n_target):
                    orig_iv = original_phone_intervals[i]
                    if orig_iv.maxTime > orig_iv.minTime: new_phone_tier.addInterval(Interval(orig_iv.minTime, orig_iv.maxTime, target_phonemes[i])); last_phone_max_time = max(last_phone_max_time, orig_iv.maxTime)
            elif n_target == 1: # Case 2: Single Target
                 total_min_time = original_phone_intervals[0].minTime; total_max_time = original_phone_intervals[-1].maxTime
                 if total_max_time > total_min_time: new_phone_tier.addInterval(Interval(total_min_time, total_max_time, target_phonemes[0])); last_phone_max_time = max(last_phone_max_time, total_max_time)
            # Case 3: Splitting (Target > Original)
            elif n_target > n_orig and n_orig >= 1:
                 orig_min = original_phone_intervals[0].minTime; orig_max = original_phone_intervals[-1].maxTime; orig_dur = orig_max - orig_min
                 if orig_dur > 1e-6:
                    use_initial_split = (n_orig == 1) # Apply special fraction only if original was truly single
                    short_dur = 0 # Initialize short_dur
                    if use_initial_split: short_dur = orig_dur * split_fraction # Calculate if needed

                    split_dur = orig_dur / n_target # Default equal split duration for other cases or later phones
                    phone_start_time = orig_min

                    for i in range(n_target - 1):
                         current_split_dur = short_dur if use_initial_split and i==0 else split_dur # Determine duration for this phone
                         phone_end_time = min(phone_start_time + current_split_dur , orig_max)
                         if phone_end_time > phone_start_time: new_phone_tier.addInterval(Interval(phone_start_time, phone_end_time, target_phonemes[i]))
                         phone_start_time = phone_end_time
                    # Last phoneme takes remaining duration
                    if orig_max > phone_start_time: new_phone_tier.addInterval(Interval(phone_start_time, orig_max, target_phonemes[n_target - 1]))
                    last_phone_max_time = max(last_phone_max_time, orig_max)
                 else: print(f"Warning: Orig phone interval for '{word_interval.mark}' zero duration. Cannot split."); new_phone_tier.addInterval(Interval(word_interval.minTime, word_interval.maxTime, "")); last_phone_max_time = max(last_phone_max_time, word_interval.maxTime)
            # Case 4: Fallback (includes n_target < n_orig)
            else:
                print(f"Warning: Phoneme length mismatch for '{word_interval.mark}' ({chosen_pinyin}). T:{n_target}{target_phonemes}, O:{n_orig}. Copying original.")
                temp_last_phone_time = word_interval.minTime
                for iv in original_phone_intervals:
                    cleaned_mark = clean_special_symbols(iv.mark)
                    if cleaned_mark and cleaned_mark not in ['AP', 'SP'] and iv.maxTime > iv.minTime: new_phone_tier.addInterval(Interval(iv.minTime, iv.maxTime, cleaned_mark)); temp_last_phone_time = max(temp_last_phone_time, iv.maxTime)
                last_phone_max_time = max(last_phone_max_time, temp_last_phone_time)
        elif chosen_pinyin in ['AP','SP']:
              if word_interval.maxTime > word_interval.minTime: new_phone_tier.addInterval(Interval(word_interval.minTime, word_interval.maxTime, chosen_pinyin)); last_phone_max_time = max(last_phone_max_time, word_interval.maxTime)
        else:
              if word_interval.maxTime > word_interval.minTime: new_phone_tier.addInterval(Interval(word_interval.minTime, word_interval.maxTime, "")); last_phone_max_time = max(last_phone_max_time, word_interval.maxTime)
        last_phone_max_time = max(last_phone_max_time, last_word_max_time)

    if tg.maxTime > last_word_max_time + tolerance: new_word_tier.addInterval(Interval(last_word_max_time, tg.maxTime, ""))
    if tg.maxTime > last_phone_max_time + tolerance: new_phone_tier.addInterval(Interval(last_phone_max_time, tg.maxTime, ""))

    processed_tg = TextGrid(name=os.path.basename(tg_path), minTime=tg.minTime, maxTime=tg.maxTime)
    processed_tg.append(new_word_tier); processed_tg.append(new_phone_tier)
    return processed_tg


# --- Main Processing Logic ---
if __name__ == "__main__":
    print("Starting M4Singer dataset processing...")
    print(f"Source Directory: {SOURCE_DATASET_DIR}")
    print(f"Output Directory: {OUTPUT_DATASET_DIR}")
    print(f"Dictionary File: {OPENCPOP_DICT_PATH}")

    pinyin_phoneme_map, _ = parse_opencpop_dict(OPENCPOP_DICT_PATH)
    if pinyin_phoneme_map is None: print("Error: Failed to load dictionary."); exit(1)
    print(f"Loaded Pinyin->Phoneme dictionary with {len(pinyin_phoneme_map)} entries.")

    if not os.path.isdir(SOURCE_DATASET_DIR): print(f"Error: Source dir '{SOURCE_DATASET_DIR}' not found."); exit(1)
    if not os.path.isdir(OUTPUT_DATASET_DIR):
        if CREATE_OUTPUT_DIR_IF_NOT_EXISTS:
            print(f"Output dir '{OUTPUT_DATASET_DIR}' not found, creating.")
            try: os.makedirs(OUTPUT_DATASET_DIR)
            except OSError as e: print(f"Error creating output dir {OUTPUT_DATASET_DIR}: {e}"); exit(1)
        else: print(f"Error: Output dir '{OUTPUT_DATASET_DIR}' not found."); exit(1)

    processed_files_count = 0; processed_songs = 0; skipped_dirs = 0; total_dirs = 0
    singer_song_dirs = []
    try:
        all_entries = os.listdir(SOURCE_DATASET_DIR)
        singer_song_dirs = [d for d in all_entries if os.path.isdir(os.path.join(SOURCE_DATASET_DIR, d)) and '#' in d]
        total_dirs = len(singer_song_dirs)
    except OSError as e: print(f"Error accessing source {SOURCE_DATASET_DIR}: {e}"); exit(1)
    print(f"Found {total_dirs} potential singer/song directories.")

    for singer_song_dir in tqdm(singer_song_dirs, desc="Processing Singers/Songs", unit="song"):
        parts = singer_song_dir.split('#', 1)
        if len(parts) != 2: skipped_dirs += 1; continue
        singer_id, song_name_original = parts[0], parts[1]
        song_name_pinyin = get_song_pinyin_name(song_name_original)
        source_song_path = os.path.join(SOURCE_DATASET_DIR, singer_song_dir)
        output_singer_dir = os.path.join(OUTPUT_DATASET_DIR, singer_id)
        output_wav_dir = os.path.join(output_singer_dir, "wav")
        output_tg_dir = os.path.join(output_singer_dir, "TextGrid")
        try: os.makedirs(output_wav_dir, exist_ok=True); os.makedirs(output_tg_dir, exist_ok=True)
        except OSError as e: print(f"Error creating output subdirs for {singer_id}: {e}"); skipped_dirs += 1; continue
        try: files_in_song = sorted([f for f in os.listdir(source_song_path) if f.lower().endswith(".wav")])
        except OSError as e: print(f"Error reading files in {source_song_path}: {e}"); skipped_dirs += 1; continue

        processed_song_flag = False
        for filename in files_in_song:
            base_name = os.path.splitext(filename)[0]; segment_id = base_name
            if not segment_id.isdigit(): continue
            wav_filename = filename; tg_filename = f"{base_name}.TextGrid"
            source_wav_path = os.path.join(source_song_path, wav_filename)
            source_tg_path = os.path.join(source_song_path, tg_filename)
            if not os.path.exists(source_tg_path): continue

            new_base_filename = f"{segment_id}_{song_name_pinyin}"
            output_wav_path = os.path.join(output_wav_dir, f"{new_base_filename}.wav")
            output_tg_path = os.path.join(output_tg_dir, f"{new_base_filename}.TextGrid")

            processed_tg = process_textgrid_file(source_tg_path, pinyin_phoneme_map, TIME_TOLERANCE, INITIAL_PHONE_SPLIT_FRACTION)

            if processed_tg:
                try: shutil.copy2(source_wav_path, output_wav_path)
                except Exception as e: print(f"  Error copying WAV {wav_filename}: {e}"); continue
                try:
                    processed_tg.write(output_tg_path)
                    processed_files_count += 1; processed_song_flag = True
                except Exception as e:
                    print(f"  Error writing TG to {output_tg_path}: {e}")
                    if os.path.exists(output_wav_path):
                        try: os.remove(output_wav_path)
                        except OSError as re: print(f"    Error removing {output_wav_path}: {re}")

        if processed_song_flag: processed_songs += 1

    print(f"\n--- Processing Summary ---")
    print(f"Total directories found: {total_dirs}")
    print(f"Directories processed (at least one file): {processed_songs}")
    print(f"Directories skipped (format error, read error, etc.): {skipped_dirs}")
    print(f"Total TextGrid/WAV pairs successfully processed: {processed_files_count}")
    print(f"Output data saved in: {OUTPUT_DATASET_DIR}")
    print("--- Done ---")