Upload folder using huggingface_hub

README.md

@@ -0,0 +1,21 @@
+---
+license: cc0-1.0
+language:
+- lv
+pipeline_tag: text-to-speech
+---
+# Latvian TTS dataset "Rūdolfs"
+
+Dataset is created from [audio books](https://www.youtube.com/@LatvijasNeredzigobiblioteka) of 
+[Latvijas Neredzīgo bibliotēka](https://neredzigobiblioteka.lv/). For permission reasons the original voice
+in the recordings has been cloned to a donor voice. 
+Audio book recordings are used with permission from Latvijas Neredzīgo bibliotēka.
+
+## Optional processing
+
+For some tastes the "s" sounds in the clips released may feel too harsh. 
+To reduce them use the `sibilant_reducer.py` script.
+
+```commandline
+uv run python sibilant_reducer.py --input-dir ../clips/wav --output-dir ../clips/wav_deessed
+```

clips/wav.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:daab56577f0f2295633635c03d185bddaf61d4531214a3d56de9e89f0bb1402d
+size 13830896049

sibilant-reducer/pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "sibilant-reducer"
+version = "0.1.0"
+description = "Automatically detects and shortens excessively long sibilant sounds in audio"
+requires-python = ">=3.10"
+dependencies = [
+    "numpy",
+    "scipy",
+    "soundfile",
+    "tqdm",
+]

sibilant-reducer/sibilant_reducer.py

@@ -0,0 +1,338 @@
+#!/usr/bin/env python3
+"""
+Sibilant Duration Reducer
+
+Automatically detects and shortens excessively long sibilant ("SSS") sounds
+in audio recordings by cutting out the middle portion and crossfading.
+"""
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+import soundfile as sf
+from scipy.signal import stft
+from tqdm import tqdm
+
+# Default parameters
+SIBILANT_FREQ_LOW = 4000  # Hz
+SIBILANT_FREQ_HIGH = 10000  # Hz
+MAX_SIBILANT_DURATION = 0.070  # seconds (70ms)
+CROSSFADE_DURATION = 0.010  # seconds (10ms)
+DETECTION_THRESHOLD = 0.1  # relative energy threshold
+MIN_GAP_DURATION = 0.020  # seconds - gaps smaller than this merge regions
+
+
+def detect_sibilants(
+    samples: np.ndarray,
+    sr: int,
+    freq_low: float,
+    freq_high: float,
+    threshold: float,
+    min_gap: float,
+) -> list[tuple[int, int]]:
+    """
+    Detect sibilant regions in audio by analyzing high-frequency energy.
+
+    Returns list of (start_sample, end_sample) tuples for detected sibilants.
+    """
+    # STFT parameters
+    nperseg = 512
+    noverlap = nperseg // 2
+    hop = nperseg - noverlap
+
+    # Compute STFT
+    freqs, times, Zxx = stft(samples, fs=sr, nperseg=nperseg, noverlap=noverlap)
+
+    # Find frequency bin indices for sibilant band
+    freq_mask = (freqs >= freq_low) & (freqs <= freq_high)
+
+    # Calculate energy in sibilant band for each frame
+    sibilant_energy = np.sum(np.abs(Zxx[freq_mask, :]) ** 2, axis=0)
+
+    # Normalize energy
+    if sibilant_energy.max() > 0:
+        sibilant_energy = sibilant_energy / sibilant_energy.max()
+    else:
+        return []
+
+    # Threshold to find sibilant frames
+    is_sibilant = sibilant_energy > threshold
+
+    # Convert frame indices to sample indices
+    frame_to_sample = lambda f: int(f * hop)
+
+    # Find contiguous regions
+    regions = []
+    in_region = False
+    start_frame = 0
+
+    for i, is_sib in enumerate(is_sibilant):
+        if is_sib and not in_region:
+            start_frame = i
+            in_region = True
+        elif not is_sib and in_region:
+            regions.append((frame_to_sample(start_frame), frame_to_sample(i)))
+            in_region = False
+
+    # Handle region extending to end
+    if in_region:
+        regions.append((frame_to_sample(start_frame), frame_to_sample(len(is_sibilant))))
+
+    # Merge regions with small gaps
+    min_gap_samples = int(min_gap * sr)
+    merged_regions = []
+
+    for start, end in regions:
+        if merged_regions and start - merged_regions[-1][1] < min_gap_samples:
+            # Merge with previous region
+            merged_regions[-1] = (merged_regions[-1][0], end)
+        else:
+            merged_regions.append((start, end))
+
+    # Clamp to valid sample range
+    merged_regions = [
+        (max(0, start), min(len(samples), end)) for start, end in merged_regions
+    ]
+
+    return merged_regions
+
+
+def shorten_sibilant(
+    samples: np.ndarray,
+    start: int,
+    end: int,
+    sr: int,
+    max_duration: float,
+    crossfade_duration: float,
+) -> tuple[np.ndarray, int]:
+    """
+    Shorten a sibilant region by cutting out the middle and crossfading.
+
+    Returns (shortened_segment, samples_removed).
+    """
+    segment = samples[start:end]
+    segment_duration = len(segment) / sr
+
+    if segment_duration <= max_duration:
+        return segment, 0
+
+    # Calculate how many samples to keep
+    max_samples = int(max_duration * sr)
+    crossfade_samples = int(crossfade_duration * sr)
+
+    # Ensure we have enough samples for crossfade
+    if max_samples < 2 * crossfade_samples:
+        crossfade_samples = max_samples // 4
+
+    # Split: keep beginning and end, remove middle
+    keep_each_side = max_samples // 2
+
+    before = segment[:keep_each_side]
+    after = segment[-keep_each_side:]
+
+    # Apply crossfade at the junction
+    if crossfade_samples > 0 and len(before) >= crossfade_samples and len(after) >= crossfade_samples:
+        fade_out = np.linspace(1.0, 0.0, crossfade_samples)
+        fade_in = np.linspace(0.0, 1.0, crossfade_samples)
+
+        # Crossfade the overlapping portion
+        before_fade = before[-crossfade_samples:] * fade_out
+        after_fade = after[:crossfade_samples] * fade_in
+        crossfaded = before_fade + after_fade
+
+        # Construct shortened segment
+        shortened = np.concatenate([
+            before[:-crossfade_samples],
+            crossfaded,
+            after[crossfade_samples:]
+        ])
+    else:
+        # No crossfade possible, just concatenate
+        shortened = np.concatenate([before, after])
+
+    samples_removed = len(segment) - len(shortened)
+    return shortened, samples_removed
+
+
+def process_audio(
+    samples: np.ndarray,
+    sr: int,
+    freq_low: float,
+    freq_high: float,
+    threshold: float,
+    max_duration: float,
+    crossfade_duration: float,
+    min_gap: float,
+) -> tuple[np.ndarray, int, int]:
+    """
+    Process audio to shorten long sibilants.
+
+    Returns (processed_samples, num_sibilants_shortened, total_samples_removed).
+    """
+    # Detect sibilants
+    regions = detect_sibilants(samples, sr, freq_low, freq_high, threshold, min_gap)
+
+    # Filter to only long sibilants
+    max_samples = int(max_duration * sr)
+    long_regions = [(s, e) for s, e in regions if (e - s) > max_samples]
+
+    if not long_regions:
+        return samples, 0, 0
+
+    # Process regions from end to start (to preserve indices)
+    result = samples.copy()
+    total_removed = 0
+
+    for start, end in reversed(long_regions):
+        shortened, removed = shorten_sibilant(
+            result, start, end, sr, max_duration, crossfade_duration
+        )
+        # Replace the region with shortened version
+        result = np.concatenate([result[:start], shortened, result[end:]])
+        total_removed += removed
+
+    return result, len(long_regions), total_removed
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Reduce duration of harsh sibilant sounds in audio files"
+    )
+    parser.add_argument(
+        "--input-dir",
+        type=Path,
+        default=Path("wav"),
+        help="Input directory containing WAV files (default: wav)",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("wav_deessed"),
+        help="Output directory for processed files (default: wav_deessed)",
+    )
+    parser.add_argument(
+        "--threshold",
+        type=float,
+        default=DETECTION_THRESHOLD,
+        help=f"Detection sensitivity 0-1 (default: {DETECTION_THRESHOLD})",
+    )
+    parser.add_argument(
+        "--max-duration",
+        type=float,
+        default=MAX_SIBILANT_DURATION * 1000,
+        help=f"Maximum sibilant duration in ms (default: {MAX_SIBILANT_DURATION * 1000})",
+    )
+    parser.add_argument(
+        "--crossfade",
+        type=float,
+        default=CROSSFADE_DURATION * 1000,
+        help=f"Crossfade duration in ms (default: {CROSSFADE_DURATION * 1000})",
+    )
+    parser.add_argument(
+        "--freq-low",
+        type=float,
+        default=SIBILANT_FREQ_LOW,
+        help=f"Lower frequency bound in Hz (default: {SIBILANT_FREQ_LOW})",
+    )
+    parser.add_argument(
+        "--freq-high",
+        type=float,
+        default=SIBILANT_FREQ_HIGH,
+        help=f"Upper frequency bound in Hz (default: {SIBILANT_FREQ_HIGH})",
+    )
+
+    args = parser.parse_args()
+
+    # Convert ms to seconds
+    max_duration = args.max_duration / 1000
+    crossfade_duration = args.crossfade / 1000
+
+    # Find input files
+    input_dir = args.input_dir
+    output_dir = args.output_dir
+
+    if not input_dir.exists():
+        print(f"Error: Input directory '{input_dir}' does not exist")
+        return 1
+
+    wav_files = list(input_dir.glob("*.wav"))
+    if not wav_files:
+        print(f"No WAV files found in '{input_dir}'")
+        return 1
+
+    # Create output directory
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"Processing {len(wav_files)} file(s)...")
+    print(f"Settings: threshold={args.threshold}, max_duration={args.max_duration}ms, "
+          f"freq_range={args.freq_low}-{args.freq_high}Hz")
+    print()
+
+    total_shortened = 0
+    total_time_removed = 0.0
+
+    for wav_file in tqdm(wav_files, desc="Processing files"):
+        # Load audio
+        samples, sr = sf.read(wav_file)
+
+        # Handle stereo by processing each channel
+        if samples.ndim == 2:
+            # Process each channel separately
+            processed_channels = []
+            file_shortened = 0
+            file_removed = 0
+
+            for ch in range(samples.shape[1]):
+                processed, shortened, removed = process_audio(
+                    samples[:, ch],
+                    sr,
+                    args.freq_low,
+                    args.freq_high,
+                    args.threshold,
+                    max_duration,
+                    crossfade_duration,
+                    MIN_GAP_DURATION,
+                )
+                processed_channels.append(processed)
+                file_shortened = max(file_shortened, shortened)
+                file_removed = max(file_removed, removed)
+
+            # Find minimum length and trim all channels to match
+            min_len = min(len(ch) for ch in processed_channels)
+            processed = np.column_stack([ch[:min_len] for ch in processed_channels])
+        else:
+            # Mono
+            processed, file_shortened, file_removed = process_audio(
+                samples,
+                sr,
+                args.freq_low,
+                args.freq_high,
+                args.threshold,
+                max_duration,
+                crossfade_duration,
+                MIN_GAP_DURATION,
+            )
+
+        # Save processed audio
+        output_path = output_dir / wav_file.name
+        sf.write(output_path, processed, sr)
+
+        if file_shortened > 0:
+            time_removed = file_removed / sr
+            total_shortened += file_shortened
+            total_time_removed += time_removed
+            tqdm.write(f"  {wav_file.name}: shortened {file_shortened} sibilant(s), "
+                      f"removed {time_removed*1000:.1f}ms")
+
+    print()
+    print(f"Done! Processed {len(wav_files)} file(s)")
+    print(f"Total: {total_shortened} sibilant(s) shortened, "
+          f"{total_time_removed*1000:.1f}ms removed")
+    print(f"Output saved to: {output_dir}/")
+
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())

sibilant-reducer/wav/YhIom1p-P-k_0225.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6fd481b1542f5104d9a3329126b412197c120b59cbbe523f143492bb5f840b0a
+size 1598444

sibilant-reducer/wav/iGGDPZ0KeJk_0118.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ab3c9b8bbff4515fd5f67194e5809382d786498317d9bcc3d2d8781a522afb9
+size 1596844

sibilant-reducer/wav/vJG48-st6bE_0055.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a210e587753bdb6c8e4ed53ae52bc6b76b2114a9eff50d5222db7918e2b6e12
+size 1595244