From fe14c6938e7389b8640248dfff6b0ba4f5b6ed2b Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Sat, 18 Apr 2026 11:15:55 +1200 Subject: [PATCH 01/36] docs: add training data pipeline design doc Add plan for LCCC-based turn detection dataset generation pipeline covering conversation-level splits, LLM text generation, and TTS synthesis. Also number existing doc files for consistent ordering. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../{plan-accuracy.md => 01-plan-accuracy.md} | 0 .../{plan-backends.md => 02-plan-backends.md} | 0 ...ntroller.md => 03-plan-turn-controller.md} | 0 docs/04-plan-training-data-pipeline.md | 250 ++++++++++++++++++ 4 files changed, 250 insertions(+) rename docs/{plan-accuracy.md => 01-plan-accuracy.md} (100%) rename docs/{plan-backends.md => 02-plan-backends.md} (100%) rename docs/{plan-turn-controller.md => 03-plan-turn-controller.md} (100%) create mode 100644 docs/04-plan-training-data-pipeline.md diff --git a/docs/plan-accuracy.md b/docs/01-plan-accuracy.md similarity index 100% rename from docs/plan-accuracy.md rename to docs/01-plan-accuracy.md diff --git a/docs/plan-backends.md b/docs/02-plan-backends.md similarity index 100% rename from docs/plan-backends.md rename to docs/02-plan-backends.md diff --git a/docs/plan-turn-controller.md b/docs/03-plan-turn-controller.md similarity index 100% rename from docs/plan-turn-controller.md rename to docs/03-plan-turn-controller.md diff --git a/docs/04-plan-training-data-pipeline.md b/docs/04-plan-training-data-pipeline.md new file mode 100644 index 0000000..6147694 --- /dev/null +++ b/docs/04-plan-training-data-pipeline.md @@ -0,0 +1,250 @@ +# Training Data Pipeline — LCCC-based Turn Detection Dataset + +## Goal + +Generate a labeled audio dataset for turn detection (complete vs. incomplete) +from Chinese conversational text, using the following pipeline: + + LCCC conversations + → split by conversation (train/eval/test) + → LLM generates complete + incomplete text variants + → TTS synthesizes speech audio (WAV) + → labeled audio dataset + +## 1. Source Dataset + +**LCCC-base** (`thu-coai/lccc`, base split — ~500K strictly filtered dialogues) + +Each sample is a multi-turn dialogue: `["你好", "你好呀", "最近怎么样", ...]` + +Why LCCC-base over LCCC-large: +- Strictly filtered — less noise, fewer broken sentences +- 500K dialogues is already more than enough (each produces multiple samples) +- Cleaner text → better TTS output + +## 2. Data Split Strategy (No Leakage) + +**Split at the conversation level, not the utterance level.** + + ┌─────────────────────────────────┐ + │ LCCC conversations │ + │ (each = multi-turn dialogue) │ + └──────────┬──────────────────────┘ + │ deterministic hash split + ▼ + ┌───────────────────────┐ + │ train 80% (~400K) │ + │ eval 10% (~ 50K) │ + │ test 10% (~ 50K) │ + └───────────────────────┘ + │ + ▼ per-utterance expansion + each utterance → 1 complete + 1 incomplete sample + +**Why conversation-level split:** +- Utterances in the same conversation share topic, vocabulary, and speaker style +- Splitting at utterance level would leak conversational context across splits +- A model could memorize topic patterns rather than learning turn boundaries + +**Implementation:** Hash the full conversation text (SHA-256) → use last byte to +assign split deterministically. This is reproducible without storing split IDs. + +```python +import hashlib + +def assign_split(conversation: list[str]) -> str: + key = "\n".join(conversation).encode() + h = int(hashlib.sha256(key).hexdigest(), 16) % 100 + if h < 80: + return "train" + elif h < 90: + return "eval" + else: + return "test" +``` + +## 3. Text Generation (LLM) + +For each utterance in a conversation, generate two variants: + +| Label | Description | Example input | Example output | +|--------------|--------------------------------------|--------------------|--------------------------| +| **complete** | Full, natural sentence (end of turn) | `"我明天要去北京出差"` | `"我明天要去北京出差。"` | +| incomplete | Truncated mid-thought (mid-turn) | `"我明天要去北京出差"` | `"我明天要去北京……"` | + +### What the LLM does + +The LLM takes each utterance and produces: +1. **Complete version** — a self-contained sentence. Minor rewording is OK to + make it sound natural when spoken aloud (remove internet slang, add proper + sentence-final particles like 啊/吧/呢). +2. **Incomplete version** — a natural truncation: cut mid-clause, trail off, + or pause at a point where the speaker clearly has more to say. + +### Model choice + +**Qwen2.5-7B-Instruct** (via `vllm` or `transformers`) + +- Best-in-class Chinese language support at the 7B scale +- Apache 2.0 license +- Runs on a single T4 GPU (16 GB VRAM) with vLLM +- Quantized (AWQ/GPTQ) variants available if VRAM is tight + +### Prompt design + +System prompt: + +> 你是一个语音数据标注助手。给定一句中文对话，生成两个版本： +> 1. 完整版：自然、口语化的完整句子，适合朗读。 +> 2. 不完整版：在句子中间自然截断，让人感觉说话者还没说完。 +> +> 只输出JSON，不要解释。 + +User input: `我明天要去北京出差` + +Expected output: + +```json +{"complete": "我明天要去北京出差。", "incomplete": "我明天要去"} +``` + +### Batch processing + +Use vLLM for high-throughput offline batch inference: + +```python +from vllm import LLM, SamplingParams + +llm = LLM(model="Qwen/Qwen2.5-7B-Instruct") +params = SamplingParams(temperature=0.7, max_tokens=128) +outputs = llm.generate(prompts, params) +``` + +### Filtering + +Post-generation quality checks: +- Parse JSON; discard malformed outputs +- Discard if `incomplete` is longer than `complete` +- Discard if `incomplete` is identical to `complete` +- Discard if either text is empty or too short (< 2 chars) +- Discard if text contains non-speech characters (URLs, hashtags, emojis) + +## 4. Speech Synthesis (TTS) + +### Model choice + +**CosyVoice 2** (Alibaba, `FunAudioLLM/CosyVoice2-0.5B`) + +- Apache 2.0 license +- Best open-source Chinese conversational TTS quality +- Supports multi-speaker with voice cloning (zero-shot) +- Streaming-capable, but we use offline batch mode here + +Alternatives considered: +- **ChatTTS** — good quality but license is restrictive (CC-BY-NC 4.0) +- **Fish Speech** — good but less mature +- **MeloTTS** — fast but less natural prosody + +### Speaker diversity + +To avoid the model learning to detect turns by speaker voice rather than +linguistic content, we need speaker diversity: + +- Use 10-20 reference voice clips (mix of male/female, age ranges) +- Randomly assign a speaker to each sample +- Track speaker ID in metadata for analysis + +### Audio format + +- **Sample rate:** 16 kHz (matches Whisper input) +- **Channels:** mono +- **Bit depth:** 16-bit PCM +- **Format:** WAV +- **Max duration:** 8 seconds (matching existing training data spec) +- Trim trailing silence to ~200 ms (matching existing data convention) + +### Batch processing + +```python +from cosyvoice import CosyVoice2 + +model = CosyVoice2("FunAudioLLM/CosyVoice2-0.5B") + +for sample in dataset: + # zero-shot with random reference speaker + audio = model.inference_zero_shot( + sample["text"], + prompt_text=speaker["prompt_text"], + prompt_speech=speaker["prompt_audio"], + ) + save_wav(audio, sample["output_path"], sr=16000) +``` + +## 5. Output Format + +### Directory structure + +Follows the existing raw data convention from upstream: + + output/ + ├── train/ + │ ├── zh/ + │ │ ├── complete-nofiller/ + │ │ │ ├── {uuid}.wav + │ │ │ └── ... + │ │ └── incomplete-nofiller/ + │ │ ├── {uuid}.wav + │ │ └── ... + ├── eval/ + │ └── zh/ + │ ├── complete-nofiller/ + │ └── incomplete-nofiller/ + └── test/ + └── zh/ + ├── complete-nofiller/ + └── incomplete-nofiller/ + +### Metadata + +Each split gets a `metadata.jsonl` with one line per sample: + +```json +{"uuid": "...", "text": "...", "label": "complete", "speaker_id": "F01", "source_conv_hash": "a3f2..."} +``` + +## 6. Pipeline Steps (Execution Order) + +| Step | Script | Input | Output | GPU? | +|------|----------------------|------------------------|------------------------|------| +| 1 | `01_split_lccc.py` | LCCC-base from HF | `splits/{train,eval,test}.jsonl` | No | +| 2 | `02_generate_text.py`| `splits/*.jsonl` | `text/{split}.jsonl` with complete/incomplete | Yes | +| 3 | `03_synthesize.py` | `text/*.jsonl` + speaker refs | `audio/{split}/zh/{label}/*.wav` | Yes | +| 4 | `04_build_dataset.py`| `audio/` tree | HuggingFace Dataset (Arrow) | No | + +Each step is idempotent — it checks for existing outputs and skips them, +so you can resume after failures. + +## 7. Scale Estimate + +Starting conservative, can scale up later: + +| Parameter | Value | Notes | +|-------------------|-------------|-----------------------------| +| Conversations | 10K (of 500K) | Start small, validate quality | +| Utterances/conv | ~4 avg | ~40K utterances | +| Samples | ~80K | 40K × 2 (complete + incomplete) | +| Audio duration | ~3s avg | ~67 hours total | +| Storage | ~8 GB | 16-bit WAV at 16 kHz | + +For comparison, upstream Smart Turn v3.2 uses 270K samples (~41 GB). +We can scale to full 500K conversations (~4M samples) once quality is validated. + +## 8. Open Questions + +- [ ] Should we include filler words (嗯, 啊, 那个) as a separate category? + Upstream data has `midfiller` and `endfiller` labels. +- [ ] Do we want to add background noise augmentation, or keep it clean and + let training handle augmentation? +- [ ] How many reference speakers are enough for good diversity? +- [ ] Should we use Qwen2.5-7B or a larger model (14B/72B) for better + text generation quality? Depends on available VRAM and time budget. From 334e583666465eb0bc971e1c3ab8824f9929a108 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Sat, 18 Apr 2026 11:56:40 +1200 Subject: [PATCH 02/36] docs: use OpenRouter for LLM and Qwen3-TTS VoiceDesign for TTS Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/04-plan-training-data-pipeline.md | 149 +++++++++++++++++-------- 1 file changed, 102 insertions(+), 47 deletions(-) diff --git a/docs/04-plan-training-data-pipeline.md b/docs/04-plan-training-data-pipeline.md index 6147694..a955c6d 100644 --- a/docs/04-plan-training-data-pipeline.md +++ b/docs/04-plan-training-data-pipeline.md @@ -83,12 +83,12 @@ The LLM takes each utterance and produces: ### Model choice -**Qwen2.5-7B-Instruct** (via `vllm` or `transformers`) +**OpenRouter API** — use any strong Chinese-capable model without local GPU. -- Best-in-class Chinese language support at the 7B scale -- Apache 2.0 license -- Runs on a single T4 GPU (16 GB VRAM) with vLLM -- Quantized (AWQ/GPTQ) variants available if VRAM is tight +- Access to Qwen, DeepSeek, Gemini, Claude, etc. via a single API +- No local GPU needed for this step — offload compute to the cloud +- Pay per token, swap models easily to compare quality +- Recommended starting model: `qwen/qwen3-235b-a22b` (best Chinese quality) ### Prompt design @@ -110,14 +110,26 @@ Expected output: ### Batch processing -Use vLLM for high-throughput offline batch inference: +Use OpenRouter with async HTTP for throughput: ```python -from vllm import LLM, SamplingParams - -llm = LLM(model="Qwen/Qwen2.5-7B-Instruct") -params = SamplingParams(temperature=0.7, max_tokens=128) -outputs = llm.generate(prompts, params) +import openai + +client = openai.AsyncOpenAI( + base_url="https://openrouter.ai/api/v1", + api_key=os.environ["OPENROUTER_API_KEY"], +) + +response = await client.chat.completions.create( + model="qwen/qwen3-235b-a22b", + messages=[ + {"role": "system", "content": SYSTEM_PROMPT}, + {"role": "user", "content": utterance}, + ], + response_format={"type": "json_object"}, + temperature=0.7, + max_tokens=128, +) ``` ### Filtering @@ -133,30 +145,53 @@ Post-generation quality checks: ### Model choice -**CosyVoice 2** (Alibaba, `FunAudioLLM/CosyVoice2-0.5B`) +**Qwen3-TTS VoiceDesign** (`Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign`) - Apache 2.0 license -- Best open-source Chinese conversational TTS quality -- Supports multi-speaker with voice cloning (zero-shot) -- Streaming-capable, but we use offline batch mode here +- 1.7B params, ~8 GB VRAM (bfloat16) +- **Voice design from natural language** — describe any voice persona in text + (age, gender, tone, emotion, speaking style) and the model creates it +- No preset speakers or reference audio needed — unlimited speaker diversity +- Runs on T4 (16 GB VRAM) + +### Voice design for speaker diversity + turn labels + +VoiceDesign takes a `voice_description` that defines the speaker persona, plus +an `instruct` that controls per-utterance prosody. This gives us two levers: + +1. **`voice_description`** — defines who is speaking (generated once per speaker) +2. **`instruct`** — defines how they speak this particular utterance (per sample) + +#### Speaker personas + +Pre-generate a pool of ~20 voice descriptions covering diverse demographics: + +```python +VOICE_POOL = [ + "年轻女性，声音清亮活泼，语速偏快", + "中年男性，声音低沉稳重，语速适中", + "年轻男性，声音明朗有活力，略带磁性", + "中年女性，声音温柔沉稳，语调平和", + "老年男性，声音沙哑浑厚，语速较慢", + # ... more variations +] +``` -Alternatives considered: -- **ChatTTS** — good quality but license is restrictive (CC-BY-NC 4.0) -- **Fish Speech** — good but less mature -- **MeloTTS** — fast but less natural prosody +Randomly assign a voice to each sample; track voice ID in metadata. -### Speaker diversity +#### Prosody instruct per label -To avoid the model learning to detect turns by speaker voice rather than -linguistic content, we need speaker diversity: +| Label | TTS instruct | Effect | +|--------------|-------------------------------------------------|--------------------------------| +| **complete** | `"用自然平稳的语气说完整句话，句尾语调下降。"` | Declarative falling intonation | +| incomplete | `"说到一半停下来，语气未完，像是还想继续说。"` | Rising/suspended intonation | -- Use 10-20 reference voice clips (mix of male/female, age ranges) -- Randomly assign a speaker to each sample -- Track speaker ID in metadata for analysis +The combination of voice_description + instruct makes synthesized audio more +realistic: diverse speakers with prosody that matches complete vs. incomplete. ### Audio format -- **Sample rate:** 16 kHz (matches Whisper input) +- **Sample rate:** 16 kHz (matches Whisper input, resample from TTS native rate) - **Channels:** mono - **Bit depth:** 16-bit PCM - **Format:** WAV @@ -166,18 +201,35 @@ linguistic content, we need speaker diversity: ### Batch processing ```python -from cosyvoice import CosyVoice2 - -model = CosyVoice2("FunAudioLLM/CosyVoice2-0.5B") - -for sample in dataset: - # zero-shot with random reference speaker - audio = model.inference_zero_shot( - sample["text"], - prompt_text=speaker["prompt_text"], - prompt_speech=speaker["prompt_audio"], - ) - save_wav(audio, sample["output_path"], sr=16000) +from qwen_tts import Qwen3TTSModel +import torch +import soundfile as sf + +model = Qwen3TTSModel.from_pretrained( + "Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign", + device_map="cuda:0", + dtype=torch.bfloat16, +) + +voice = "年轻女性，声音清亮活泼，语速偏快" + +# Complete sample — falling intonation +wavs, sr = model.generate_voice_design( + text=sample["complete"], + language="Chinese", + voice_description=voice, + instruct="用自然平稳的语气说完整句话，句尾语调下降。", +) +sf.write("complete.wav", wavs[0], sr) + +# Incomplete sample — suspended intonation +wavs, sr = model.generate_voice_design( + text=sample["incomplete"], + language="Chinese", + voice_description=voice, + instruct="说到一半停下来，语气未完，像是还想继续说。", +) +sf.write("incomplete.wav", wavs[0], sr) ``` ## 5. Output Format @@ -214,12 +266,12 @@ Each split gets a `metadata.jsonl` with one line per sample: ## 6. Pipeline Steps (Execution Order) -| Step | Script | Input | Output | GPU? | -|------|----------------------|------------------------|------------------------|------| -| 1 | `01_split_lccc.py` | LCCC-base from HF | `splits/{train,eval,test}.jsonl` | No | -| 2 | `02_generate_text.py`| `splits/*.jsonl` | `text/{split}.jsonl` with complete/incomplete | Yes | -| 3 | `03_synthesize.py` | `text/*.jsonl` + speaker refs | `audio/{split}/zh/{label}/*.wav` | Yes | -| 4 | `04_build_dataset.py`| `audio/` tree | HuggingFace Dataset (Arrow) | No | +| Step | Script | Input | Output | Compute | +|------|----------------------|------------------------|------------------------|---------| +| 1 | `01_split_lccc.py` | LCCC-base from HF | `splits/{train,eval,test}.jsonl` | CPU | +| 2 | `02_generate_text.py`| `splits/*.jsonl` | `text/{split}.jsonl` with complete/incomplete | OpenRouter API | +| 3 | `03_synthesize.py` | `text/*.jsonl` | `audio/{split}/zh/{label}/*.wav` | GPU (Qwen3-TTS) | +| 4 | `04_build_dataset.py`| `audio/` tree | HuggingFace Dataset (Arrow) | CPU | Each step is idempotent — it checks for existing outputs and skips them, so you can resume after failures. @@ -245,6 +297,9 @@ We can scale to full 500K conversations (~4M samples) once quality is validated. Upstream data has `midfiller` and `endfiller` labels. - [ ] Do we want to add background noise augmentation, or keep it clean and let training handle augmentation? -- [ ] How many reference speakers are enough for good diversity? -- [ ] Should we use Qwen2.5-7B or a larger model (14B/72B) for better - text generation quality? Depends on available VRAM and time budget. +- [ ] How many voice descriptions should we pre-generate for the VoiceDesign + speaker pool? Starting with ~20, but more may help generalization. +- [ ] Which OpenRouter model gives the best cost/quality tradeoff for text + generation? Start with Qwen3-235B, compare with cheaper alternatives. +- [ ] Should we vary the TTS `instruct` prompts per sample (e.g., different + emotions) or keep them consistent per label? From c2e684fd39306b8ce63567ca91e34e2906e1b080 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Sat, 18 Apr 2026 12:05:57 +1200 Subject: [PATCH 03/36] docs: LLM generates TTS instructs per sample Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/04-plan-training-data-pipeline.md | 87 ++++++++++++++++---------- 1 file changed, 54 insertions(+), 33 deletions(-) diff --git a/docs/04-plan-training-data-pipeline.md b/docs/04-plan-training-data-pipeline.md index a955c6d..c9a98e8 100644 --- a/docs/04-plan-training-data-pipeline.md +++ b/docs/04-plan-training-data-pipeline.md @@ -65,21 +65,26 @@ def assign_split(conversation: list[str]) -> str: ## 3. Text Generation (LLM) -For each utterance in a conversation, generate two variants: +For each utterance in a conversation, generate two variants with TTS instructions: -| Label | Description | Example input | Example output | -|--------------|--------------------------------------|--------------------|--------------------------| -| **complete** | Full, natural sentence (end of turn) | `"我明天要去北京出差"` | `"我明天要去北京出差。"` | -| incomplete | Truncated mid-thought (mid-turn) | `"我明天要去北京出差"` | `"我明天要去北京……"` | +| Label | Fields | Example | +|--------------|--------------------|--------------------------------------------------| +| **complete** | text + tts_instruct | `"我明天要去北京出差。"` + `"Calm declarative tone, falling intonation at the end."` | +| incomplete | text + tts_instruct | `"我明天要去"` + `"Hesitant, trailing off mid-sentence, rising intonation."` | ### What the LLM does The LLM takes each utterance and produces: 1. **Complete version** — a self-contained sentence. Minor rewording is OK to make it sound natural when spoken aloud (remove internet slang, add proper - sentence-final particles like 啊/吧/呢). + sentence-final particles like 啊/吧/呢). Plus a TTS instruct describing + the speaking style for a completed turn. 2. **Incomplete version** — a natural truncation: cut mid-clause, trail off, - or pause at a point where the speaker clearly has more to say. + or pause at a point where the speaker clearly has more to say. Plus a TTS + instruct describing the speaking style for an interrupted/unfinished turn. + +TTS instructs must be in **English** (Qwen3-TTS instruct language). +Text content must be in **Chinese** (target language). ### Model choice @@ -94,18 +99,34 @@ The LLM takes each utterance and produces: System prompt: -> 你是一个语音数据标注助手。给定一句中文对话，生成两个版本： -> 1. 完整版：自然、口语化的完整句子，适合朗读。 -> 2. 不完整版：在句子中间自然截断，让人感觉说话者还没说完。 +> You are a speech data labelling assistant. Given a Chinese conversational +> utterance, produce two versions: +> +> 1. **complete**: A natural, spoken-style complete sentence in Chinese, plus +> a short English TTS instruction describing how a speaker would say a +> finished thought (e.g. tone, intonation, emotion). +> 2. **incomplete**: A naturally truncated version of the sentence in Chinese +> (cut mid-clause, trail off), plus a short English TTS instruction +> describing how a speaker would sound when interrupted or still thinking. > -> 只输出JSON，不要解释。 +> Output JSON only, no explanation. The `text` fields must be Chinese. +> The `tts_instruct` fields must be English. User input: `我明天要去北京出差` Expected output: ```json -{"complete": "我明天要去北京出差。", "incomplete": "我明天要去"} +{ + "complete": { + "text": "我明天要去北京出差。", + "tts_instruct": "Calm and steady, declarative tone with falling intonation at the end." + }, + "incomplete": { + "text": "我明天要去", + "tts_instruct": "Hesitant, trailing off mid-sentence as if thinking about what to say next." + } +} ``` ### Batch processing @@ -135,11 +156,12 @@ response = await client.chat.completions.create( ### Filtering Post-generation quality checks: -- Parse JSON; discard malformed outputs -- Discard if `incomplete` is longer than `complete` -- Discard if `incomplete` is identical to `complete` -- Discard if either text is empty or too short (< 2 chars) -- Discard if text contains non-speech characters (URLs, hashtags, emojis) +- Parse JSON; discard malformed outputs (must have complete/incomplete with text + tts_instruct) +- Discard if `incomplete.text` is longer than `complete.text` +- Discard if `incomplete.text` is identical to `complete.text` +- Discard if any `text` is empty or too short (< 2 chars) +- Discard if `text` contains non-speech characters (URLs, hashtags, emojis) +- Discard if `tts_instruct` is empty or not in English ## 4. Speech Synthesis (TTS) @@ -179,15 +201,14 @@ VOICE_POOL = [ Randomly assign a voice to each sample; track voice ID in metadata. -#### Prosody instruct per label +#### Prosody instruct per sample -| Label | TTS instruct | Effect | -|--------------|-------------------------------------------------|--------------------------------| -| **complete** | `"用自然平稳的语气说完整句话，句尾语调下降。"` | Declarative falling intonation | -| incomplete | `"说到一半停下来，语气未完，像是还想继续说。"` | Rising/suspended intonation | +The `tts_instruct` is **not hardcoded** — it is generated by the LLM in step 2 +alongside the text, tailored to each specific utterance. This produces more +natural and varied prosody than a single fixed instruction per label. -The combination of voice_description + instruct makes synthesized audio more -realistic: diverse speakers with prosody that matches complete vs. incomplete. +The combination of voice_description + per-sample instruct makes synthesized +audio more realistic: diverse speakers with prosody that matches the content. ### Audio format @@ -213,21 +234,21 @@ model = Qwen3TTSModel.from_pretrained( voice = "年轻女性，声音清亮活泼，语速偏快" -# Complete sample — falling intonation +# Complete sample — instruct from LLM wavs, sr = model.generate_voice_design( - text=sample["complete"], + text=sample["complete"]["text"], language="Chinese", voice_description=voice, - instruct="用自然平稳的语气说完整句话，句尾语调下降。", + instruct=sample["complete"]["tts_instruct"], # e.g. "Calm and steady, falling intonation." ) sf.write("complete.wav", wavs[0], sr) -# Incomplete sample — suspended intonation +# Incomplete sample — instruct from LLM wavs, sr = model.generate_voice_design( - text=sample["incomplete"], + text=sample["incomplete"]["text"], language="Chinese", voice_description=voice, - instruct="说到一半停下来，语气未完，像是还想继续说。", + instruct=sample["incomplete"]["tts_instruct"], # e.g. "Hesitant, trailing off mid-sentence." ) sf.write("incomplete.wav", wavs[0], sr) ``` @@ -261,7 +282,7 @@ Follows the existing raw data convention from upstream: Each split gets a `metadata.jsonl` with one line per sample: ```json -{"uuid": "...", "text": "...", "label": "complete", "speaker_id": "F01", "source_conv_hash": "a3f2..."} +{"uuid": "...", "text": "...", "tts_instruct": "...", "label": "complete", "voice_id": "V03", "source_conv_hash": "a3f2..."} ``` ## 6. Pipeline Steps (Execution Order) @@ -301,5 +322,5 @@ We can scale to full 500K conversations (~4M samples) once quality is validated. speaker pool? Starting with ~20, but more may help generalization. - [ ] Which OpenRouter model gives the best cost/quality tradeoff for text generation? Start with Qwen3-235B, compare with cheaper alternatives. -- [ ] Should we vary the TTS `instruct` prompts per sample (e.g., different - emotions) or keep them consistent per label? +- [ ] Should we add guardrails on the LLM-generated TTS instructs (e.g., max + length, banned keywords) to keep them within Qwen3-TTS's capabilities? From 6d58b9ebe67529911ce18e199e88adf89ff1f64b Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Sat, 18 Apr 2026 19:55:21 +1200 Subject: [PATCH 04/36] docs: define incomplete turn patterns and resolve open questions Co-Authored-By: Claude Opus 4.6 (1M context) --- docs/04-plan-training-data-pipeline.md | 52 +++++++++++++++++--------- 1 file changed, 34 insertions(+), 18 deletions(-) diff --git a/docs/04-plan-training-data-pipeline.md b/docs/04-plan-training-data-pipeline.md index c9a98e8..4433b98 100644 --- a/docs/04-plan-training-data-pipeline.md +++ b/docs/04-plan-training-data-pipeline.md @@ -79,9 +79,23 @@ The LLM takes each utterance and produces: make it sound natural when spoken aloud (remove internet slang, add proper sentence-final particles like 啊/吧/呢). Plus a TTS instruct describing the speaking style for a completed turn. -2. **Incomplete version** — a natural truncation: cut mid-clause, trail off, - or pause at a point where the speaker clearly has more to say. Plus a TTS - instruct describing the speaking style for an interrupted/unfinished turn. +2. **Incomplete version** — must simulate how real incomplete turns sound in + conversation. Plus a TTS instruct describing the speaking style. + +### Incomplete turn patterns + +The incomplete version should randomly follow one of these real-world patterns: + +| Pattern | Example | Description | +|----------------------|--------------------------------|------------------------------------------| +| **Mid-clause cut** | `"我觉得这个..."` | Stops between words/clauses | +| **Filler trailing** | `"嗯...那个...就是说..."` | Thinking aloud with filler words | +| **Compound break** | `"我先去买菜，然后..."` | Finishes one clause but clearly has more | +| **Self-correction** | `"我想...不对，我是说..."` | Restarts mid-thought | +| **Interrupted** | `"你能不能帮我把那个——"` | Cut off abruptly by another speaker | + +Filler words (嗯, 啊, 那个, 就是) are a natural part of incomplete turns and +should be included in the generated text, not treated as a separate category. TTS instructs must be in **English** (Qwen3-TTS instruct language). Text content must be in **Chinese** (target language). @@ -105,9 +119,14 @@ System prompt: > 1. **complete**: A natural, spoken-style complete sentence in Chinese, plus > a short English TTS instruction describing how a speaker would say a > finished thought (e.g. tone, intonation, emotion). -> 2. **incomplete**: A naturally truncated version of the sentence in Chinese -> (cut mid-clause, trail off), plus a short English TTS instruction -> describing how a speaker would sound when interrupted or still thinking. +> 2. **incomplete**: A realistically incomplete version of the sentence in +> Chinese. Randomly pick one of these patterns: +> - Mid-clause cut: stop between words/clauses ("我觉得这个...") +> - Filler trailing: think aloud with fillers ("嗯...那个...就是说...") +> - Compound break: finish one clause but have more ("我先去买菜，然后...") +> - Self-correction: restart mid-thought ("我想...不对，我是说...") +> - Interrupted: cut off abruptly ("你能不能帮我把那个——") +> Plus a short English TTS instruction matching the chosen pattern. > > Output JSON only, no explanation. The `text` fields must be Chinese. > The `tts_instruct` fields must be English. @@ -312,15 +331,12 @@ Starting conservative, can scale up later: For comparison, upstream Smart Turn v3.2 uses 270K samples (~41 GB). We can scale to full 500K conversations (~4M samples) once quality is validated. -## 8. Open Questions - -- [ ] Should we include filler words (嗯, 啊, 那个) as a separate category? - Upstream data has `midfiller` and `endfiller` labels. -- [ ] Do we want to add background noise augmentation, or keep it clean and - let training handle augmentation? -- [ ] How many voice descriptions should we pre-generate for the VoiceDesign - speaker pool? Starting with ~20, but more may help generalization. -- [ ] Which OpenRouter model gives the best cost/quality tradeoff for text - generation? Start with Qwen3-235B, compare with cheaper alternatives. -- [ ] Should we add guardrails on the LLM-generated TTS instructs (e.g., max - length, banned keywords) to keep them within Qwen3-TTS's capabilities? +## 8. Decisions + +- **Fillers** — not a separate category. Filler words (嗯, 啊, 那个) are a + natural part of incomplete turns and are included in the generated text. +- **Background noise** — no augmentation in this pipeline. Keep audio clean; + augmentation is handled during training. +- **Voice pool size** — 20 voice descriptions for the VoiceDesign speaker pool. +- **OpenRouter model** — start with `qwen/qwen3-235b-a22b`, iterate as needed. +- **TTS instruct guardrails** — iterate on quality; no upfront constraints. From 7322f30748177bc759ad9f0ecc25c70879e60c2b Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Sat, 18 Apr 2026 22:29:24 +1200 Subject: [PATCH 05/36] docs: reorganize training docs and add dataset research Move pipeline plan into training/smart-turn-zh/, add README and dataset survey for Mandarin conversational corpora. Co-Authored-By: Claude Opus 4.6 (1M context) --- training/smart-turn-zh/README.md | 20 +++++ .../smart-turn-zh/plan-data.md | 0 .../smart-turn-zh/research/01-datasets.md | 84 +++++++++++++++++++ 3 files changed, 104 insertions(+) create mode 100644 training/smart-turn-zh/README.md rename docs/04-plan-training-data-pipeline.md => training/smart-turn-zh/plan-data.md (100%) create mode 100644 training/smart-turn-zh/research/01-datasets.md diff --git a/training/smart-turn-zh/README.md b/training/smart-turn-zh/README.md new file mode 100644 index 0000000..5641fa1 --- /dev/null +++ b/training/smart-turn-zh/README.md @@ -0,0 +1,20 @@ +# Smart Turn — Mandarin (smart-turn-zh) + +Mandarin-Chinese variant of the Smart Turn detector: fine-tuning the upstream +[Pipecat Smart Turn](../pipecat-smart-turn/) architecture (Whisper-Tiny encoder ++ binary classification head) on Chinese conversational audio. + +## Layout + +- [`plan-data.md`](plan-data.md) — dataset construction plan (under revision) +- [`research/`](research/) — surveys and open questions feeding the plans + - [`01-datasets.md`](research/01-datasets.md) — OpenSLR + HuggingFace dataset survey +- `data/` — data pipeline scripts +- `notebooks/` — Jupyter exploration +- `train/` — training scripts (later) + +## Status + +Design phase. The data pipeline plan in `plan-data.md` is the original +LLM-rewriting + TTS approach; we are revising toward real conversational +corpora — see `research/datasets.md` for the source-corpus analysis. diff --git a/docs/04-plan-training-data-pipeline.md b/training/smart-turn-zh/plan-data.md similarity index 100% rename from docs/04-plan-training-data-pipeline.md rename to training/smart-turn-zh/plan-data.md diff --git a/training/smart-turn-zh/research/01-datasets.md b/training/smart-turn-zh/research/01-datasets.md new file mode 100644 index 0000000..feaffe7 --- /dev/null +++ b/training/smart-turn-zh/research/01-datasets.md @@ -0,0 +1,84 @@ +# Datasets — Mandarin Conversational Audio for Turn Detection + +Survey of candidate corpora for training a Mandarin Smart Turn detector. +Sources reviewed: [OpenSLR](http://www.openslr.org/resources.php) (full list, +SLR1–SLR162) and HuggingFace. + +## What we need + +Spontaneous conversational audio with **per-speaker turn boundaries**: + +- Real conversation — readers don't yield turns naturally; read-speech corpora + cannot supervise turn detection as a primary signal. +- Turn timestamps, or per-speaker channels we can VAD ourselves. +- Permissive license — we want commercial-friendly model weights. + +## Recommended basket (Mandarin, commercial-OK) + +About 338 h of pre-annotated Mandarin conversation across three corpora. + +| SLR | Name | Hours | Per-speaker channels | License | Why | +|---|---|---|---|---|---| +| [119](http://www.openslr.org/119/) | AliMeeting | 118 | yes (headset) | CC BY-SA 4.0 | 2–4 spk meetings, clean per-speaker tracks, diarization ready. Best fit. | +| [159](http://www.openslr.org/159/) | AISHELL-5 | 100 | partial (training-set near-field) | CC BY-SA 4.0 | In-car free conversation, 2–4 spk. Closest to voice-agent setting. | +| [111](http://www.openslr.org/111/) | AISHELL-4 | 120 | no (8-ch array only) | CC BY-SA 4.0 | 4–8 spk meetings, more overlap; needs careful filtering. | + +For scale once the base pipeline works: + +| SLR | Name | Hours | License | Catch | +|---|---|---|---|---| +| [121](http://www.openslr.org/121/) | WenetSpeech | 10,000+ | CC BY 4.0 | Multi-domain (podcasts, interviews, audiobooks). Not pre-segmented — needs diarization (e.g. pyannote-audio). | + +## Reserve / research-only + +| SLR | Name | Hours | License | Why on hold | +|---|---|---|---|---| +| [123](http://www.openslr.org/123/) | MAGICDATA Conversational | 180 | **CC BY-NC-ND 4.0** | Non-commercial only. Use only if scope stays research. | +| [155](http://www.openslr.org/155/) | SBCSAE | 20 | **CC BY-ND 3.0** | No-derivatives blocks publishing processed clips. Small. American English. | + +## Optional English coverage (multilingual model) + +| SLR | Name | Hours | License | Notes | +|---|---|---|---|---| +| [16](http://www.openslr.org/16/) | AMI Corpus | ~100 | CC BY 4.0 | Classic meeting corpus, headset + array. | +| [150](http://www.openslr.org/150/) | CHiME-6 | ~50 | CC BY-SA 4.0 | Dinner-party recordings, JSON annotations. | + +## Not useful for the primary turn signal + +**Read speech** (no natural turn yielding): SLR18 THCHS-30, SLR33 AISHELL-1, +SLR38 Free ST, SLR47 Primewords, SLR62 aidatatang_200zh, SLR68 MAGICDATA Read +755h, SLR93 AISHELL-3, SLR138 SHALCAS22A. Could be reused as text/voice +sources for synthetic-truncation augmentation if we go that route. + +**Other excluded** (full sweep): software mirrors (SLR2/3/4/9/11/15/23/48/50/56), +impulse-response and noise databases (SLR13/17/20/26/28), wake-word and +hotword (SLR85/87/120), speaker verification (SLR82 CN-Celeb, SLR156), +pronunciation dictionaries (SLR8/14/21/29/34), text-only corpora (SLR55/153), +emotional read-speech TTS (SLR88/110/115/136/161), scripture (SLR129/132), +handwriting (SLR84), nonverbal vocalizations (SLR99), test fixtures +(SLR1/81), forensics (SLR162), whistled language (SLR137), single-speaker TTS +data for low-resource languages (most of the "Crowdsourced high-quality" +series, Thorsten Müller, Sinhala TTS, etc.), and endangered-language +documentation (SLR89/92/107/124/133/147/148/158/149). + +## License notes + +**CC BY-SA 4.0 share-alike** applies to *derived datasets* — if we publish +processed clips, the clip dataset itself must be CC BY-SA. Trained model +weights are generally not treated as derivatives of training data in most +jurisdictions, so a permissive weight release is usually fine, but worth +confirming with whoever handles licensing if we plan to ship weights. + +**CC BY-NC-ND** (SLR123) blocks both commercial use and derivative datasets — +incompatible with any pipeline that publishes processed clips. + +## Open questions + +- WenetSpeech subsets: which of its domains (podcast / interview / meeting / + audiobook / vlog) are spontaneous enough to be worth diarizing? Need to + inspect the metadata before committing GPU time. +- Whether to include SLR123 (RAMC, 180h) under a research-only carve-out — + doubles available Mandarin conversation hours but adds license-tracking + burden across artifacts. +- Multilingual scope: is English (AMI + CHiME-6) in scope for v1, or + Mandarin-only? From 32f4b289e90afb6f96ae6ddb842754476628d334 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Sun, 19 Apr 2026 20:32:19 +1200 Subject: [PATCH 06/36] feat: add ASR transcription notebook with Paraformer-zh Add Jupyter notebook for running FunASR Paraformer-zh on WAV files and saving word-level ASR results to JSONL. Includes Makefile for venv setup and JupyterLab, requirements.txt, and gitignore updates. Co-Authored-By: Claude Opus 4.6 (1M context) --- .gitignore | 9 + training/smart-turn-zh/Makefile | 25 + training/smart-turn-zh/data/wav/.gitkeep | 0 .../notebooks/01-asr-transcribe.ipynb | 1033 +++++++++++++++++ training/smart-turn-zh/requirements.txt | 6 + 5 files changed, 1073 insertions(+) create mode 100644 training/smart-turn-zh/Makefile create mode 100644 training/smart-turn-zh/data/wav/.gitkeep create mode 100644 training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb create mode 100644 training/smart-turn-zh/requirements.txt diff --git a/.gitignore b/.gitignore index fb6236d..cf5793c 100644 --- a/.gitignore +++ b/.gitignore @@ -14,3 +14,12 @@ __pycache__/ # Generated mel reference tensors (regenerate with scripts/gen_reference.py) *.mel.npy + +# Jupyter checkpoints +.ipynb_checkpoints/ + +# Training venvs +training/**/.venv/ + +# Training data WAV files +training/smart-turn-zh/data/wav/*.wav diff --git a/training/smart-turn-zh/Makefile b/training/smart-turn-zh/Makefile new file mode 100644 index 0000000..43f12ce --- /dev/null +++ b/training/smart-turn-zh/Makefile @@ -0,0 +1,25 @@ +VENV := .venv +PYTHON := $(VENV)/bin/python +PIP := $(VENV)/bin/pip + +.PHONY: help venv notebook clean + +help: + @echo "Available targets:" + @echo " venv Create virtualenv and install dependencies" + @echo " notebook Launch Jupyter notebook server" + @echo " clean Remove virtualenv" + +venv: $(VENV)/bin/activate + +$(VENV)/bin/activate: requirements.txt + python3 -m venv $(VENV) + $(PIP) install --upgrade pip + $(PIP) install -r requirements.txt + touch $(VENV)/bin/activate + +notebook: venv + $(VENV)/bin/jupyter lab notebooks/ + +clean: + rm -rf $(VENV) diff --git a/training/smart-turn-zh/data/wav/.gitkeep b/training/smart-turn-zh/data/wav/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb b/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb new file mode 100644 index 0000000..6936a31 --- /dev/null +++ b/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb @@ -0,0 +1,1033 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ASR Transcription with Paraformer-zh\n", + "\n", + "Load WAV files from a folder, run Paraformer-zh (via FunASR) with FSMN-VAD,\n", + "and save word-level ASR results to JSONL." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# %pip install funasr modelscope soundfile" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "# -- Configure these paths --\n", + "WAV_DIR = Path(\"../data/wav\") # folder containing .wav files\n", + "OUTPUT_PATH = Path(\"../data/asr_results.jsonl\")\n", + "\n", + "WAV_DIR.mkdir(parents=True, exist_ok=True)\n", + "OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "funasr version: 1.3.1.\n", + "Check update of funasr, and it would cost few times. You may disable it by set `disable_update=True` in AutoModel\n", + "You are using the latest version of funasr-1.3.1\n", + "Downloading Model from https://www.modelscope.cn to directory: /Users/eason/.cache/modelscope/hub/models/iic/speech_seaco_paraformer_large_asr_nat-zh-cn-16k-common-vocab8404-pytorch\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:trust_remote_code: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading Model from https://www.modelscope.cn to directory: /Users/eason/.cache/modelscope/hub/models/iic/speech_fsmn_vad_zh-cn-16k-common-pytorch\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:trust_remote_code: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading Model from https://www.modelscope.cn to directory: /Users/eason/.cache/modelscope/hub/models/iic/punc_ct-transformer_cn-en-common-vocab471067-large\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:trust_remote_code: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model loaded.\n" + ] + } + ], + "source": [ + "from funasr import AutoModel\n", + "\n", + "model = AutoModel(\n", + " model=\"paraformer-zh\", # ASR — best Chinese accuracy at 220M params\n", + " vad_model=\"fsmn-vad\", # VAD with timestamps\n", + " punc_model=\"ct-punc\", # punctuation restoration\n", + ")\n", + "print(\"Model loaded.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 2 WAV files in ../data/wav\n", + " R8001_M8004_MS801.wav\n", + " R8003_M8001_MS801.wav\n" + ] + } + ], + "source": [ + "wav_files = sorted(WAV_DIR.glob(\"*.wav\"))\n", + "print(f\"Found {len(wav_files)} WAV files in {WAV_DIR}\")\n", + "for f in wav_files[:5]:\n", + " print(f\" {f.name}\")\n", + "if len(wav_files) > 5:\n", + " print(f\" ... and {len(wav_files) - 5} more\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "rtf_avg: 0.225: 100%|\u001b[34m█████████\u001b[0m| 1/1 [00:03<00:00, 3.12s/it]\u001b[0m\n", + " 0%|\u001b[31m \u001b[0m| 0/1 [00:00 Date: Sun, 19 Apr 2026 20:42:50 +1200 Subject: [PATCH 07/36] chore: ignore ASR results output file Co-Authored-By: Claude Opus 4.6 (1M context) --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index cf5793c..85c6ff3 100644 --- a/.gitignore +++ b/.gitignore @@ -21,5 +21,6 @@ __pycache__/ # Training venvs training/**/.venv/ -# Training data WAV files +# Training data training/smart-turn-zh/data/wav/*.wav +training/smart-turn-zh/data/asr_results.jsonl From a94f80db5696b0e8c4b3961ce131590ce664fb87 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Sun, 19 Apr 2026 20:43:31 +1200 Subject: [PATCH 08/36] feat: add MPS support and speed benchmarks to ASR notebook Co-Authored-By: Claude Opus 4.6 (1M context) --- .../notebooks/01-asr-transcribe.ipynb | 925 +----------------- 1 file changed, 23 insertions(+), 902 deletions(-) diff --git a/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb b/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb index 6936a31..c19dfa0 100644 --- a/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb +++ b/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -37,62 +37,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "funasr version: 1.3.1.\n", - "Check update of funasr, and it would cost few times. You may disable it by set `disable_update=True` in AutoModel\n", - "You are using the latest version of funasr-1.3.1\n", - "Downloading Model from https://www.modelscope.cn to directory: /Users/eason/.cache/modelscope/hub/models/iic/speech_seaco_paraformer_large_asr_nat-zh-cn-16k-common-vocab8404-pytorch\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:trust_remote_code: False\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading Model from https://www.modelscope.cn to directory: /Users/eason/.cache/modelscope/hub/models/iic/speech_fsmn_vad_zh-cn-16k-common-pytorch\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:trust_remote_code: False\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading Model from https://www.modelscope.cn to directory: /Users/eason/.cache/modelscope/hub/models/iic/punc_ct-transformer_cn-en-common-vocab471067-large\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:trust_remote_code: False\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model loaded.\n" - ] - } - ], + "outputs": [], "source": [ "from funasr import AutoModel\n", "\n", @@ -100,25 +47,16 @@ " model=\"paraformer-zh\", # ASR — best Chinese accuracy at 220M params\n", " vad_model=\"fsmn-vad\", # VAD with timestamps\n", " punc_model=\"ct-punc\", # punctuation restoration\n", + " device=\"mps\", # MPS for Mac\n", ")\n", "print(\"Model loaded.\")" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 2 WAV files in ../data/wav\n", - " R8001_M8004_MS801.wav\n", - " R8003_M8001_MS801.wav\n" - ] - } - ], + "outputs": [], "source": [ "wav_files = sorted(WAV_DIR.glob(\"*.wav\"))\n", "print(f\"Found {len(wav_files)} WAV files in {WAV_DIR}\")\n", @@ -132,832 +70,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "rtf_avg: 0.225: 100%|\u001b[34m█████████\u001b[0m| 1/1 [00:03<00:00, 3.12s/it]\u001b[0m\n", - " 0%|\u001b[31m \u001b[0m| 0/1 [00:00 rtf_avg: 0.069, time_speech: 2068.000, time_escape: 143.4924.00s/it]\n", + "\n", + "With MPS\n", + "\n", + "> rtf_avg: 0.009, time_speech: 2068.000, time_escape: 19.374:9.86s/it]\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -1000,13 +128,6 @@ " print(f\" sentences: {r['sentences'][:3]}\")\n", " print()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 99453bdbd488c5d30c446b0c83384b2d9b9aa7ee Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Sun, 19 Apr 2026 21:02:04 +1200 Subject: [PATCH 09/36] feat: add Silero VAD notebook and VAD comparison doc Co-Authored-By: Claude Opus 4.6 (1M context) --- .gitignore | 5 +- .../smart-turn-zh/docs/01-vad-comparison.md | 76 +++++++++++++++++++ training/smart-turn-zh/notebooks/02-vad.ipynb | 73 ++++++++++++++++++ training/smart-turn-zh/notebooks/README.md | 26 +++++++ 4 files changed, 179 insertions(+), 1 deletion(-) create mode 100644 training/smart-turn-zh/docs/01-vad-comparison.md create mode 100644 training/smart-turn-zh/notebooks/02-vad.ipynb create mode 100644 training/smart-turn-zh/notebooks/README.md diff --git a/.gitignore b/.gitignore index 85c6ff3..920cf4a 100644 --- a/.gitignore +++ b/.gitignore @@ -23,4 +23,7 @@ training/**/.venv/ # Training data training/smart-turn-zh/data/wav/*.wav -training/smart-turn-zh/data/asr_results.jsonl +training/smart-turn-zh/data/*.jsonl + +# Training references +training/smart-turn-zh/refs/*.pdf \ No newline at end of file diff --git a/training/smart-turn-zh/docs/01-vad-comparison.md b/training/smart-turn-zh/docs/01-vad-comparison.md new file mode 100644 index 0000000..a8fe3c5 --- /dev/null +++ b/training/smart-turn-zh/docs/01-vad-comparison.md @@ -0,0 +1,76 @@ +# VAD Model Comparison for Chinese Filler Detection + +## Use Case + +Detect speech regions in Chinese podcast audio, including soft fillers +(呃/嗯/啊) that ASR typically skips. The goal: **VAD active ∧ ASR silent = +filler candidates** (PodcastFillers, Zhu et al. 2022). + +Key requirements: +- Catches soft/quiet speech (fillers are often quiet) +- Configurable activation threshold (paper found 0.1 critical) +- Fine temporal resolution (10ms ideal) +- Runs on MacBook Pro (Apple Silicon) + +## Comparison + +| | FSMN-VAD | Silero VAD | WebRTC VAD | pyannote.audio | TEN VAD | +|---|---|---|---|---|---| +| **Source** | Alibaba / FunASR | Silero | Google | pyannote | TEN Framework | +| **Params** | 0.4M | ~70KB (quantized) | <1MB compiled | ~68M | lightweight ONNX | +| **Resolution** | 200ms chunks | 10ms+ configurable | 10/20/30ms fixed | 10ms | 10–16ms | +| **Threshold** | Configurable (speech_noise_thres) | Probability output, fully tunable | Aggressiveness 0–3 (coarse) | Probability output, fully tunable | Configurable, default 0.5 | +| **Chinese** | Native (5000h Mandarin) | General (6000+ langs, no zh-specific) | Language-agnostic | Trained on AISHELL + AliMeeting | General | +| **Soft fillers** | Good, but 200ms chunks may blur boundaries | Catches at low threshold (~0.1–0.3) | May miss quiet fillers | Best accuracy on soft boundaries | Less documented | +| **Mac perf** | CPU, fast for 0.4M | ~40μs/chunk on M2 Max | Very fast CPU | Slow on CPU (68M params) | arm64 native + ONNX | +| **MPS/GPU** | Yes (via FunASR) | MLX native | N/A (CPU only) | MPS supported | ONNX only | +| **License** | Model-specific (check HF) | MIT | BSD | MIT | Apache 2.0 | + +## Analysis + +### FSMN-VAD +- **Pro**: Already in our stack (FunASR). Chinese-native, production-proven. +- **Con**: 200ms chunk size is coarser than ideal. Fine boundary detection + for short fillers (150–400ms) may lose precision. + +### Silero VAD +- **Pro**: Tiny, fast, 10ms resolution, MIT license. Threshold tunable to + ~0.1 for soft speech. MLX native on Apple Silicon. +- **Con**: Not Chinese-optimized. Lightweight design means less sophisticated + boundary detection. + +### WebRTC VAD +- **Pro**: Mature, fast, 10ms native resolution. +- **Con**: No probability output — binary decisions with coarse aggressiveness + levels (0–3). Hard to tune for soft fillers. No fine-grained threshold. + +### pyannote.audio (segmentation-3.0) +- **Pro**: Best accuracy. 10ms resolution. Trained on Chinese datasets + (AISHELL, AliMeeting). Best at catching soft speech boundaries. +- **Con**: 68M params — slow on CPU. Overkill if we only need binary VAD. + +### TEN VAD +- **Pro**: 10ms resolution, superior precision vs WebRTC and Silero. Apache 2.0. +- **Con**: Newer (2024–2025), fewer production deployments. Less documented + for Chinese/soft speech. + +## Recommendation + +**Silero VAD** as primary choice: +- 10ms resolution matches what the paper uses +- Threshold tunable to 0.1 (critical finding from the paper) +- Tiny and fast on MacBook +- MIT license +- Good enough for candidate generation — the classifier stage handles precision + +**FSMN-VAD** as comparison baseline since it's already in our pipeline. + +If accuracy on soft boundaries proves insufficient, upgrade to **pyannote.audio**. + +## References + +- [PodcastFillers paper](../refs/2203.pdf) — Section 2.2: VAD threshold 0.1, candidates 150ms–2s +- [Silero VAD](https://github.com/snakers4/silero-vad) +- [FSMN-VAD](https://huggingface.co/funasr/fsmn-vad) +- [pyannote.audio](https://github.com/pyannote/pyannote-audio) +- [TEN VAD](https://github.com/TEN-framework/ten-vad) diff --git a/training/smart-turn-zh/notebooks/02-vad.ipynb b/training/smart-turn-zh/notebooks/02-vad.ipynb new file mode 100644 index 0000000..648e104 --- /dev/null +++ b/training/smart-turn-zh/notebooks/02-vad.ipynb @@ -0,0 +1,73 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": "# VAD Detection with Silero VAD\n\nRun Silero VAD on WAV files to detect speech regions.\nUses low threshold (0.1) to catch soft fillers (呃/嗯/啊).\nOutputs `[start_ms, end_ms]` segments per file." + }, + { + "cell_type": "code", + "source": "from pathlib import Path\n\nWAV_DIR = Path(\"../data/wav\")\nOUTPUT_PATH = Path(\"../data/vad_results.jsonl\")\n\n# Silero VAD parameters — per PodcastFillers paper, 0.1 threshold is critical\n# to catch soft fillers without missing them\nTHRESHOLD = 0.1\nMIN_SPEECH_MS = 150 # merge speech chunks shorter than this\nMIN_SILENCE_MS = 100 # don't split on silences shorter than this\n\nOUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)", + "metadata": {}, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": "import torch\n\nmodel, utils = torch.hub.load(\n repo_or_dir=\"snakers4/silero-vad\",\n model=\"silero_vad\",\n)\n\n(get_speech_timestamps, _, read_audio, _, _) = utils\n\n# Move to MPS if available\ndevice = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cpu\")\nmodel = model.to(device)\nprint(f\"Silero VAD loaded on {device}\")" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "wav_files = sorted(WAV_DIR.glob(\"*.wav\"))\n", + "print(f\"Found {len(wav_files)} WAV files in {WAV_DIR}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": "import json\n\nSAMPLE_RATE = 16000\n\nfor i, wav_path in enumerate(wav_files):\n wav = read_audio(str(wav_path), sampling_rate=SAMPLE_RATE).to(device)\n\n timestamps = get_speech_timestamps(\n wav,\n model,\n threshold=THRESHOLD,\n min_speech_duration_ms=MIN_SPEECH_MS,\n min_silence_duration_ms=MIN_SILENCE_MS,\n sampling_rate=SAMPLE_RATE,\n return_seconds=False,\n )\n\n # Convert sample indices to [start_ms, end_ms]\n segments = [\n [int(t[\"start\"] / SAMPLE_RATE * 1000), int(t[\"end\"] / SAMPLE_RATE * 1000)]\n for t in timestamps\n ]\n\n with open(OUTPUT_PATH, \"a\", encoding=\"utf-8\") as f:\n record = {\"file\": wav_path.name, \"segments\": segments}\n f.write(json.dumps(record, ensure_ascii=False) + \"\\n\")\n\n if (i + 1) % 10 == 0 or (i + 1) == len(wav_files):\n print(f\"[{i + 1}/{len(wav_files)}] {wav_path.name} — {len(segments)} segments\")\n\nprint(f\"\\nDone. Results saved to {OUTPUT_PATH}\")" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Preview results\n", + "with open(OUTPUT_PATH, \"r\", encoding=\"utf-8\") as f:\n", + " for line in f:\n", + " r = json.loads(line)\n", + " segs = r[\"segments\"]\n", + " print(f\"--- {r['file']} ---\")\n", + " print(f\" {len(segs)} speech segments\")\n", + " for s in segs[:5]:\n", + " print(f\" {s[0]:>8}–{s[1]:>8} ms ({s[1] - s[0]} ms)\")\n", + " if len(segs) > 5:\n", + " print(f\" ... and {len(segs) - 5} more\")\n", + " print()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/training/smart-turn-zh/notebooks/README.md b/training/smart-turn-zh/notebooks/README.md new file mode 100644 index 0000000..3f6f126 --- /dev/null +++ b/training/smart-turn-zh/notebooks/README.md @@ -0,0 +1,26 @@ +# Notebooks — Filler Detection Pipeline + +Following the PodcastFillers approach (Zhu et al., 2022): +filler candidates = regions where **VAD is active** but **ASR produces no words**. + +## Pipeline + +``` +WAV files + → 01 ASR transcription (Paraformer-zh, word-level timestamps) + → 02 VAD detection (FSMN-VAD, speech region timestamps) + → 03 Filler candidates (VAD ∧ ¬ASR, duration filter 150ms–2s) + → 04 ... (labeling / classification TBD) +``` + +## Notebooks + +| # | Notebook | Input | Output | Description | +|---|----------|-------|--------|-------------| +| 01 | `01-asr-transcribe` | `data/wav/*.wav` | `data/asr_results.jsonl` | Paraformer-zh ASR with word timestamps | +| 02 | `02-vad` | `data/wav/*.wav` | `data/vad_results.jsonl` | FSMN-VAD speech region detection | +| 03 | TBD | ASR + VAD results | `data/filler_candidates.jsonl` | Compute VAD ∧ ¬ASR gaps | + +## Reference + +- `refs/2203.pdf` — PodcastFillers: Filler Word Detection and Classification (Zhu et al., 2022) From ab73047d50a1695c36504325b9051494a0de07b0 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Sun, 19 Apr 2026 21:19:49 +1200 Subject: [PATCH 10/36] feat: raw VAD probs, visualization, make install - Save per-frame speech probabilities as .npy instead of pre-filtered segments - Add 3-panel visualization (overview, zoom, histogram) - Add tqdm progress bars, torchcodec/matplotlib/numpy deps - Add make install target for re-installing into existing venv Co-Authored-By: Claude Opus 4.6 (1M context) --- .gitignore | 1 + training/smart-turn-zh/Makefile | 6 +- training/smart-turn-zh/notebooks/02-vad.ipynb | 155 +++++++++++++++--- training/smart-turn-zh/requirements.txt | 4 + 4 files changed, 142 insertions(+), 24 deletions(-) diff --git a/.gitignore b/.gitignore index 920cf4a..7e74934 100644 --- a/.gitignore +++ b/.gitignore @@ -24,6 +24,7 @@ training/**/.venv/ # Training data training/smart-turn-zh/data/wav/*.wav training/smart-turn-zh/data/*.jsonl +training/smart-turn-zh/data/vad_probs/ # Training references training/smart-turn-zh/refs/*.pdf \ No newline at end of file diff --git a/training/smart-turn-zh/Makefile b/training/smart-turn-zh/Makefile index 43f12ce..b7a4a6d 100644 --- a/training/smart-turn-zh/Makefile +++ b/training/smart-turn-zh/Makefile @@ -2,11 +2,12 @@ VENV := .venv PYTHON := $(VENV)/bin/python PIP := $(VENV)/bin/pip -.PHONY: help venv notebook clean +.PHONY: help venv install notebook clean help: @echo "Available targets:" @echo " venv Create virtualenv and install dependencies" + @echo " install Re-install dependencies into existing venv" @echo " notebook Launch Jupyter notebook server" @echo " clean Remove virtualenv" @@ -18,6 +19,9 @@ $(VENV)/bin/activate: requirements.txt $(PIP) install -r requirements.txt touch $(VENV)/bin/activate +install: venv + $(PIP) install -r requirements.txt + notebook: venv $(VENV)/bin/jupyter lab notebooks/ diff --git a/training/smart-turn-zh/notebooks/02-vad.ipynb b/training/smart-turn-zh/notebooks/02-vad.ipynb index 648e104..23facf8 100644 --- a/training/smart-turn-zh/notebooks/02-vad.ipynb +++ b/training/smart-turn-zh/notebooks/02-vad.ipynb @@ -3,21 +3,53 @@ { "cell_type": "markdown", "metadata": {}, - "source": "# VAD Detection with Silero VAD\n\nRun Silero VAD on WAV files to detect speech regions.\nUses low threshold (0.1) to catch soft fillers (呃/嗯/啊).\nOutputs `[start_ms, end_ms]` segments per file." + "source": [ + "# VAD Detection with Silero VAD\n", + "\n", + "Run Silero VAD on WAV files and save raw per-frame speech probabilities.\n", + "Each frame is 32ms (512 samples at 16kHz). Save raw probs for visualization\n", + "so we can pick threshold/filtering parameters later." + ] }, { "cell_type": "code", - "source": "from pathlib import Path\n\nWAV_DIR = Path(\"../data/wav\")\nOUTPUT_PATH = Path(\"../data/vad_results.jsonl\")\n\n# Silero VAD parameters — per PodcastFillers paper, 0.1 threshold is critical\n# to catch soft fillers without missing them\nTHRESHOLD = 0.1\nMIN_SPEECH_MS = 150 # merge speech chunks shorter than this\nMIN_SILENCE_MS = 100 # don't split on silences shorter than this\n\nOUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)", - "metadata": {}, "execution_count": null, - "outputs": [] + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import numpy as np\n", + "\n", + "WAV_DIR = Path(\"../data/wav\")\n", + "OUTPUT_DIR = Path(\"../data/vad_probs\")\n", + "\n", + "OUTPUT_DIR.mkdir(parents=True, exist_ok=True)\n", + "\n", + "SAMPLE_RATE = 16000\n", + "WINDOW_SIZE = 512 # 32ms per frame at 16kHz" + ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": "import torch\n\nmodel, utils = torch.hub.load(\n repo_or_dir=\"snakers4/silero-vad\",\n model=\"silero_vad\",\n)\n\n(get_speech_timestamps, _, read_audio, _, _) = utils\n\n# Move to MPS if available\ndevice = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cpu\")\nmodel = model.to(device)\nprint(f\"Silero VAD loaded on {device}\")" + "source": [ + "import torch\n", + "\n", + "model, utils = torch.hub.load(\n", + " repo_or_dir=\"snakers4/silero-vad\",\n", + " model=\"silero_vad\",\n", + " trust_repo=True,\n", + ")\n", + "\n", + "(get_speech_timestamps, _, read_audio, _, _) = utils\n", + "\n", + "# Move to MPS if available\n", + "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cpu\")\n", + "model = model.to(device)\n", + "print(f\"Silero VAD loaded on {device}\")" + ] }, { "cell_type": "code", @@ -34,40 +66,117 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": "import json\n\nSAMPLE_RATE = 16000\n\nfor i, wav_path in enumerate(wav_files):\n wav = read_audio(str(wav_path), sampling_rate=SAMPLE_RATE).to(device)\n\n timestamps = get_speech_timestamps(\n wav,\n model,\n threshold=THRESHOLD,\n min_speech_duration_ms=MIN_SPEECH_MS,\n min_silence_duration_ms=MIN_SILENCE_MS,\n sampling_rate=SAMPLE_RATE,\n return_seconds=False,\n )\n\n # Convert sample indices to [start_ms, end_ms]\n segments = [\n [int(t[\"start\"] / SAMPLE_RATE * 1000), int(t[\"end\"] / SAMPLE_RATE * 1000)]\n for t in timestamps\n ]\n\n with open(OUTPUT_PATH, \"a\", encoding=\"utf-8\") as f:\n record = {\"file\": wav_path.name, \"segments\": segments}\n f.write(json.dumps(record, ensure_ascii=False) + \"\\n\")\n\n if (i + 1) % 10 == 0 or (i + 1) == len(wav_files):\n print(f\"[{i + 1}/{len(wav_files)}] {wav_path.name} — {len(segments)} segments\")\n\nprint(f\"\\nDone. Results saved to {OUTPUT_PATH}\")" + "source": [ + "from tqdm.auto import tqdm\n", + "\n", + "for wav_path in tqdm(wav_files, desc=\"Files\"):\n", + " wav = read_audio(str(wav_path), sampling_rate=SAMPLE_RATE).to(device)\n", + "\n", + " # Extract per-frame speech probabilities\n", + " chunks = range(0, len(wav), WINDOW_SIZE)\n", + " probs = []\n", + " for start in tqdm(chunks, desc=wav_path.stem, leave=False):\n", + " chunk = wav[start : start + WINDOW_SIZE]\n", + " if len(chunk) < WINDOW_SIZE:\n", + " chunk = torch.nn.functional.pad(chunk, (0, WINDOW_SIZE - len(chunk)))\n", + " prob = model(chunk, SAMPLE_RATE).item()\n", + " probs.append(prob)\n", + " model.reset_states()\n", + "\n", + " # Save as .npy — one float32 per 32ms frame\n", + " out_path = OUTPUT_DIR / f\"{wav_path.stem}.npy\"\n", + " np.save(out_path, np.array(probs, dtype=np.float32))\n", + "\n", + "print(f\"\\nDone. Saved {len(wav_files)} prob arrays to {OUTPUT_DIR}\")" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Preview results\n", - "with open(OUTPUT_PATH, \"r\", encoding=\"utf-8\") as f:\n", - " for line in f:\n", - " r = json.loads(line)\n", - " segs = r[\"segments\"]\n", - " print(f\"--- {r['file']} ---\")\n", - " print(f\" {len(segs)} speech segments\")\n", - " for s in segs[:5]:\n", - " print(f\" {s[0]:>8}–{s[1]:>8} ms ({s[1] - s[0]} ms)\")\n", - " if len(segs) > 5:\n", - " print(f\" ... and {len(segs) - 5} more\")\n", - " print()" + "# Preview: plot speech probabilities\n", + "import matplotlib.pyplot as plt\n", + "\n", + "npy_files = sorted(OUTPUT_DIR.glob(\"*.npy\"))\n", + "probs = np.load(npy_files[0])\n", + "time_s = np.arange(len(probs)) * WINDOW_SIZE / SAMPLE_RATE\n", + "\n", + "# Overview (full file, downsampled for readability)\n", + "fig, axes = plt.subplots(3, 1, figsize=(16, 8), sharex=False)\n", + "\n", + "# 1) Full file overview — use fill to show density\n", + "axes[0].fill_between(time_s, probs, alpha=0.6)\n", + "axes[0].set_title(f\"{npy_files[0].stem} — full ({time_s[-1]:.0f}s)\")\n", + "axes[0].set_ylim(0, 1)\n", + "axes[0].axhline(y=0.5, color=\"r\", linestyle=\"--\", alpha=0.5, label=\"0.5\")\n", + "axes[0].axhline(y=0.1, color=\"orange\", linestyle=\"--\", alpha=0.5, label=\"0.1\")\n", + "axes[0].legend(loc=\"upper right\")\n", + "\n", + "# 2) First 60s zoomed in\n", + "mask = time_s <= 60\n", + "axes[1].fill_between(time_s[mask], probs[mask], alpha=0.6)\n", + "axes[1].plot(time_s[mask], probs[mask], linewidth=0.3, color=\"C0\")\n", + "axes[1].set_title(\"First 60s\")\n", + "axes[1].set_ylim(0, 1)\n", + "axes[1].axhline(y=0.5, color=\"r\", linestyle=\"--\", alpha=0.5)\n", + "axes[1].axhline(y=0.1, color=\"orange\", linestyle=\"--\", alpha=0.5)\n", + "\n", + "# 3) Histogram of probabilities\n", + "axes[2].hist(probs, bins=100, edgecolor=\"none\", alpha=0.7)\n", + "axes[2].set_xlabel(\"Speech probability\")\n", + "axes[2].set_ylabel(\"Frame count\")\n", + "axes[2].set_title(\"Probability distribution\")\n", + "axes[2].axvline(x=0.5, color=\"r\", linestyle=\"--\", alpha=0.5, label=\"0.5\")\n", + "axes[2].axvline(x=0.1, color=\"orange\", linestyle=\"--\", alpha=0.5, label=\"0.1\")\n", + "axes[2].legend()\n", + "\n", + "for ax in axes[:2]:\n", + " ax.set_ylabel(\"P(speech)\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", "name": "python", - "version": "3.11.0" + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.3" } }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/training/smart-turn-zh/requirements.txt b/training/smart-turn-zh/requirements.txt index 81198c6..c8ae105 100644 --- a/training/smart-turn-zh/requirements.txt +++ b/training/smart-turn-zh/requirements.txt @@ -1,6 +1,10 @@ torch torchaudio +torchcodec funasr modelscope soundfile +numpy +matplotlib +tqdm jupyterlab From 778a3b8e66a6ebcffdabbfe5f1b04476d8e021d8 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 10:16:40 +1200 Subject: [PATCH 11/36] docs: add data structures reference for ASR and VAD results Co-Authored-By: Claude Opus 4.6 (1M context) --- .../smart-turn-zh/docs/02-data-structures.md | 109 ++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 training/smart-turn-zh/docs/02-data-structures.md diff --git a/training/smart-turn-zh/docs/02-data-structures.md b/training/smart-turn-zh/docs/02-data-structures.md new file mode 100644 index 0000000..65cd8ee --- /dev/null +++ b/training/smart-turn-zh/docs/02-data-structures.md @@ -0,0 +1,109 @@ +# Data Structures + +Artifacts produced by the notebook pipeline (`01-asr-transcribe`, `02-vad`) and their schemas. + +## Directory Layout + +``` +data/ +├── wav/ # Source audio +│ ├── R8001_M8004_MS801.wav # 8-ch, 16 kHz, PCM-16 +│ └── R8003_M8001_MS801.wav +├── asr_results.jsonl # ASR transcriptions (all files) +└── vad_probs/ # Per-frame speech probabilities + ├── R8001_M8004_MS801.npy + └── R8003_M8001_MS801.npy +``` + +## Source Audio (`data/wav/*.wav`) + +| Property | Value | +|-------------|--------------------------------| +| Format | RIFF WAVE, PCM 16-bit | +| Channels | 8 (per-speaker headset mics) | +| Sample rate | 16 kHz | +| Source | AliMeeting (SLR-119) meetings | + +## ASR Results (`data/asr_results.jsonl`) + +**Format**: JSONL — one JSON object per line. +**Producer**: `notebooks/01-asr-transcribe.ipynb` (Paraformer-zh + FSMN-VAD + ct-punc). + +### Record Schema + +```jsonc +{ + "file": "R8001_M8004_MS801.wav", // source filename + "text": "全文转写结果...", // full transcription (punctuated) + "sentences": [ /* see below */ ], + "timestamp": [ /* see below */ ] +} +``` + +### `sentences` Array Element + +Each element is one sentence/chunk segmented by the ASR model. + +```jsonc +{ + "text": "啊，", // punctuated text + "raw_text": "啊", // text without punctuation + "start": 7130, // start time (ms) + "end": 7370, // end time (ms) + "timestamp": [[7130, 7370]] // per-word [start_ms, end_ms] pairs +} +``` + +| Field | Type | Unit | Description | +|-------------|------------------|------|------------------------------------------| +| `text` | string | — | Sentence with restored punctuation | +| `raw_text` | string | — | Same sentence, no punctuation | +| `start` | int | ms | Sentence start time | +| `end` | int | ms | Sentence end time | +| `timestamp` | array of [int, int] | ms | Per-word start/end pairs (10 ms frames) | + +### Top-level `timestamp` Array + +Flat array of all per-word `[start_ms, end_ms]` pairs across the entire file (same data as the union of per-sentence timestamps). + +## VAD Probabilities (`data/vad_probs/*.npy`) + +**Format**: NumPy `.npy`, 1-D `float32` array. +**Producer**: `notebooks/02-vad.ipynb` (Silero VAD). + +| Property | Value | +|-------------------|-------------------------------| +| Shape | `(num_frames,)` | +| Dtype | `float32` | +| Frame size | 512 samples = **32 ms** @ 16 kHz | +| Value range | `[0.0, 1.0]` — P(speech) | +| Index → time | `frame[i]` → `i * 32 ms` | + +### Loading + +```python +import numpy as np +probs = np.load("data/vad_probs/R8001_M8004_MS801.npy") +# probs[i] = speech probability at time i * 32 ms +``` + +### File Details + +| File | Frames | Duration | +|---------------------------|---------|------------| +| `R8001_M8004_MS801.npy` | 49,183 | ~1,573.9 s | +| `R8003_M8001_MS801.npy` | 64,625 | ~2,068.0 s | + +## Cross-referencing ASR and VAD + +ASR timestamps are in **milliseconds**; VAD frames are **32 ms** each. + +```python +# Convert ASR ms timestamp to VAD frame index +vad_frame = asr_start_ms // 32 + +# Convert VAD frame index to ms +time_ms = vad_frame * 32 +``` + +This alignment is used in the next pipeline step (filler candidate extraction): regions where VAD is active (`prob > threshold`) but ASR produces no recognized words. From 65506ac690d6c675391c8329e0360c8cce70c326 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 10:44:41 +1200 Subject: [PATCH 12/36] feat: save ASR results as per-file JSON Output one JSON file per WAV into data/asr_results/ instead of appending all results to a single JSONL, matching the pattern used for VAD probs. Co-Authored-By: Claude Opus 4.6 (1M context) --- .gitignore | 1 + .../notebooks/01-asr-transcribe.ipynb | 49 +++++++++++-------- 2 files changed, 30 insertions(+), 20 deletions(-) diff --git a/.gitignore b/.gitignore index 7e74934..081d9f3 100644 --- a/.gitignore +++ b/.gitignore @@ -25,6 +25,7 @@ training/**/.venv/ training/smart-turn-zh/data/wav/*.wav training/smart-turn-zh/data/*.jsonl training/smart-turn-zh/data/vad_probs/ +training/smart-turn-zh/data/asr_results/ # Training references training/smart-turn-zh/refs/*.pdf \ No newline at end of file diff --git a/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb b/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb index c19dfa0..130bf11 100644 --- a/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb +++ b/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb @@ -29,10 +29,10 @@ "\n", "# -- Configure these paths --\n", "WAV_DIR = Path(\"../data/wav\") # folder containing .wav files\n", - "OUTPUT_PATH = Path(\"../data/asr_results.jsonl\")\n", + "OUTPUT_DIR = Path(\"../data/asr_results\")\n", "\n", "WAV_DIR.mkdir(parents=True, exist_ok=True)\n", - "OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)" + "OUTPUT_DIR.mkdir(parents=True, exist_ok=True)" ] }, { @@ -81,20 +81,22 @@ " sentence_timestamp=True,\n", " )\n", "\n", - " with open(OUTPUT_PATH, \"a\", encoding=\"utf-8\") as f:\n", - " for item in res:\n", - " record = {\n", - " \"file\": wav_path.name,\n", - " \"text\": item.get(\"text\", \"\"),\n", - " \"sentences\": item.get(\"sentence_info\", []),\n", - " \"timestamp\": item.get(\"timestamp\", []),\n", - " }\n", - " f.write(json.dumps(record, ensure_ascii=False) + \"\\n\")\n", + " # Save one JSON per WAV file\n", + " out_path = OUTPUT_DIR / f\"{wav_path.stem}.json\"\n", + " records = []\n", + " for item in res:\n", + " records.append({\n", + " \"text\": item.get(\"text\", \"\"),\n", + " \"sentences\": item.get(\"sentence_info\", []),\n", + " \"timestamp\": item.get(\"timestamp\", []),\n", + " })\n", + " with open(out_path, \"w\", encoding=\"utf-8\") as f:\n", + " json.dump(records, f, ensure_ascii=False, indent=2)\n", "\n", " if (i + 1) % 10 == 0 or (i + 1) == len(wav_files):\n", " print(f\"[{i + 1}/{len(wav_files)}] {wav_path.name}\")\n", "\n", - "print(f\"\\nDone. Results saved to {OUTPUT_PATH}\")" + "print(f\"\\nDone. Results saved to {OUTPUT_DIR}\")" ] }, { @@ -119,15 +121,22 @@ "outputs": [], "source": [ "# Preview results\n", - "with open(OUTPUT_PATH, \"r\", encoding=\"utf-8\") as f:\n", - " for line in f:\n", - " r = json.loads(line)\n", - " print(f\"--- {r['file']} ---\")\n", - " print(f\" text: {r['text']}\")\n", - " if r[\"sentences\"]:\n", - " print(f\" sentences: {r['sentences'][:3]}\")\n", - " print()" + "for json_path in sorted(OUTPUT_DIR.glob(\"*.json\"))[:5]:\n", + " r = json.loads(json_path.read_text(encoding=\"utf-8\"))\n", + " print(f\"--- {json_path.stem} ---\")\n", + " for item in r:\n", + " print(f\" text: {item['text']}\")\n", + " if item[\"sentences\"]:\n", + " print(f\" sentences: {item['sentences'][:3]}\")\n", + " print()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 86eed0cc0d95be3de0483be48722f6a4570f802d Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 10:46:40 +1200 Subject: [PATCH 13/36] docs: update data structures for per-file ASR output Co-Authored-By: Claude Opus 4.6 (1M context) --- .../smart-turn-zh/docs/02-data-structures.md | 25 +++++++++++-------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/training/smart-turn-zh/docs/02-data-structures.md b/training/smart-turn-zh/docs/02-data-structures.md index 65cd8ee..247e1de 100644 --- a/training/smart-turn-zh/docs/02-data-structures.md +++ b/training/smart-turn-zh/docs/02-data-structures.md @@ -9,7 +9,9 @@ data/ ├── wav/ # Source audio │ ├── R8001_M8004_MS801.wav # 8-ch, 16 kHz, PCM-16 │ └── R8003_M8001_MS801.wav -├── asr_results.jsonl # ASR transcriptions (all files) +├── asr_results/ # Per-file ASR transcriptions +│ ├── R8001_M8004_MS801.json +│ └── R8003_M8001_MS801.json └── vad_probs/ # Per-frame speech probabilities ├── R8001_M8004_MS801.npy └── R8003_M8001_MS801.npy @@ -24,20 +26,23 @@ data/ | Sample rate | 16 kHz | | Source | AliMeeting (SLR-119) meetings | -## ASR Results (`data/asr_results.jsonl`) +## ASR Results (`data/asr_results/*.json`) -**Format**: JSONL — one JSON object per line. +**Format**: JSON — one file per WAV, named `{wav_stem}.json`. **Producer**: `notebooks/01-asr-transcribe.ipynb` (Paraformer-zh + FSMN-VAD + ct-punc). -### Record Schema +### File Schema + +Each file contains a JSON array of record objects: ```jsonc -{ - "file": "R8001_M8004_MS801.wav", // source filename - "text": "全文转写结果...", // full transcription (punctuated) - "sentences": [ /* see below */ ], - "timestamp": [ /* see below */ ] -} +[ + { + "text": "全文转写结果...", // full transcription (punctuated) + "sentences": [ /* see below */ ], + "timestamp": [ /* see below */ ] + } +] ``` ### `sentences` Array Element From 8cfc663a19c3e64aba2744d72515e289e4352eec Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 11:08:56 +1200 Subject: [PATCH 14/36] docs: add audio viewer plan Co-Authored-By: Claude Opus 4.6 (1M context) --- .../smart-turn-zh/docs/03-audio-viewer.md | 223 ++++++++++++++++++ 1 file changed, 223 insertions(+) create mode 100644 training/smart-turn-zh/docs/03-audio-viewer.md diff --git a/training/smart-turn-zh/docs/03-audio-viewer.md b/training/smart-turn-zh/docs/03-audio-viewer.md new file mode 100644 index 0000000..1d97be7 --- /dev/null +++ b/training/smart-turn-zh/docs/03-audio-viewer.md @@ -0,0 +1,223 @@ +# Audio Viewer — Plan + +A browser-based tool for inspecting audio alongside VAD probabilities and ASR +transcriptions. Designed for 1-hour recordings at interactive frame rates. + +## Goal + +Accelerate data review for the training pipeline. Load a WAV file with its +matching VAD and ASR outputs, visualize everything on a synchronized timeline, +and search/navigate ASR text to jump to specific moments. + +## Requirements + +### Functional + +1. **File upload** — drag-and-drop or file picker for three inputs: + - `.wav` audio (any channel count, 16 kHz, PCM-16) + - `.npy` VAD probabilities (float32, 32 ms frames) + - `.json` ASR result (sentence-level timestamps) + +2. **Waveform display** — amplitude over time. Supports any channel count + (1, 2, 4, 8, ...). Individual channel selection or a merged "all channels" + view that overlays every channel on a single waveform. + +3. **Spectrogram display** — time-frequency view of the selected channel. + +4. **VAD probability curve** — stacked below the waveform, showing P(speech) + per 32 ms frame. Two configurable threshold lines: **entry** (e.g. 0.3) and + **exit** (e.g. 0.1). Hysteresis logic: speech region starts when probs rise + above entry, ends when they drop below exit. Active speech regions are + filled with one color; inactive regions with another. + +5. **ASR transcript panel** — scrollable sentence list with timestamps. Clicking + a sentence seeks the playback cursor and centers the viewport. + +6. **Text search** — search box filters ASR sentences by keyword. Highlights + matching segments on the timeline. Previous/Next buttons (+ keyboard + shortcuts) cycle through results. + +7. **Audio playback** — play/pause, click-to-seek on waveform, playback cursor + that scrolls the viewport. + +### Non-functional + +- Handle **1-hour audio** (57.6 M samples per channel) without lag. +- Smooth zoom from full-file overview down to individual samples. +- All processing client-side — no server required. Open `index.html` and go. + +## Data Inputs + +All three formats are documented in `02-data-structures.md`. Key details +relevant to the viewer: + +| Input | Size (1 hr) | Notes | +|-------|-------------|-------| +| WAV (N-ch, 16 kHz, 16-bit) | varies | Decode via Web Audio API; select channel or merge all | +| VAD .npy (float32) | ~450 KB | ~112 K frames; parse npy header + raw ArrayBuffer | +| ASR .json | ~50-200 KB | Array of records with `sentences[].{start,end,text}` | + +### Parsing `.npy` in the browser + +NumPy v1.0 `.npy` format: 6-byte magic + 2-byte version + 2-byte header length ++ ASCII header (dtype, shape, order) + raw data. For 1-D float32 arrays this is +trivial — read the header to get length, then wrap the remaining bytes as a +`Float32Array`. + +## Architecture + +``` +viewer/ +├── index.html # single entry point +├── src/ +│ ├── main.ts # bootstrap, file loading, layout +│ ├── audio.ts # WAV decode, channel extraction, LOD cache +│ ├── waveform.ts # Canvas waveform renderer +│ ├── spectrogram.ts # Canvas spectrogram renderer (FFT in Worker) +│ ├── vad.ts # .npy parser + VAD curve renderer +│ ├── asr.ts # ASR JSON loader + transcript panel + search +│ ├── timeline.ts # shared time axis, zoom/pan state, cursor sync +│ └── fft-worker.ts # Web Worker for spectrogram computation +├── package.json +├── tsconfig.json +└── vite.config.ts +``` + +**Stack**: TypeScript + Vite (dev server + build). No framework — vanilla DOM +for the panels, Canvas 2D for all visualizations. Keeps the bundle tiny and +avoids framework overhead on large data. + +## Performance Strategy + +### Waveform — level-of-detail (LOD) decimation + +Raw samples per channel for 1 hr: **57.6 M**. A screen is ~2000 px wide. +Drawing all samples is pointless and slow. + +**Approach**: pre-compute a min/max mipmap pyramid on load. + +``` +Level 0: raw samples (57.6 M points) +Level 1: min/max per 64 samples (~900 K points) +Level 2: min/max per 256 (~225 K points) +Level 3: min/max per 1024 (~56 K points) +Level 4: min/max per 4096 (~14 K points) +... +``` + +At render time, pick the level where each pixel covers ~1 bucket. Draw a filled +shape between min and max per pixel column. This is O(screen_width) per frame +regardless of zoom level. + +Build the pyramid in a **Web Worker** so the UI stays responsive during load. + +### Spectrogram — viewport-only FFT + +Computing a full STFT for 1 hour is expensive (~3.6 M frames at hop=16). +Instead: + +1. Compute FFT **only for the visible time range** plus a small margin. +2. Cache computed tiles (e.g. 10-second chunks) in a tile map. +3. On pan/zoom, render cached tiles and compute missing ones in a Worker. +4. FFT size: 512 (32 ms at 16 kHz) — matches VAD frame size, gives 256 freq + bins up to 8 kHz. Fast enough for real-time viewport updates. + +Render to an off-screen canvas, then `drawImage` to the visible canvas — +avoids per-pixel DOM work. + +### VAD curve + +~112 K points for 1 hour. Apply the same LOD approach as waveform (average +instead of min/max). At full zoom-out the curve is already only ~2 K points +per screen width — nearly free. + +### ASR overlay + +Sentence count is small (a few hundred). No special optimization needed. +On search, build a Set of matching sentence indices, then highlight their +time spans on the timeline canvas. + +### General + +- **Typed arrays everywhere** — `Float32Array` / `Int16Array` for audio and + VAD data. No JS array copies. +- **`requestAnimationFrame`** for synchronized redraws — batch all dirty + canvases into one frame. +- **Debounced zoom/pan** — pointer events update viewport state; rendering + reads state on rAF. +- **Channel switching** — re-slice from the decoded `AudioBuffer` (kept in + memory), rebuild LOD pyramid. ~1 s for 1-hour file. "All" mode averages + channels into a single waveform, or overlays them with per-channel colors. + +## UI Layout + +``` +┌──────────────────────────────────────────────────────┐ +│ [Drop zone / file pickers] [Channel ▾ All] [▶ ⏸] │ +├──────────────────────────────────────────────────────┤ +│ Waveform ░░░▓▓▓▓▓▓░░░░▓▓▓▓░░░░░░ │ ← Canvas +│ VAD probs ─────╱╲──╱╲╲──────╱╲───────────── │ ← Canvas (stacked) +│ Spectrogram ▒▒▒▓▓▓▓▒▒▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ │ ← Canvas +├────────────────────────────┬─────────────────────────┤ +│ [🔍 Search ASR...] │ Time axis / minimap │ +│ ─────────────────────────│──────────────────────────│ +│ 00:01.23 啊，我觉得... │ │ +│ 00:05.67 对对对，就是 │ │ +│ 00:12.34 然后我们... │ (overview bar showing │ +│ ... │ full file with viewport │ +│ [◀ Prev] [Next ▶] │ indicator) │ +└────────────────────────────┴─────────────────────────┘ +``` + +- **Top row**: file upload area, channel selector, playback controls. +- **Middle**: three vertically stacked canvases sharing a time axis. Scroll + wheel zooms, click-drag pans. All canvases pan/zoom in sync. +- **Bottom left**: ASR transcript panel with search. Clicking a sentence + scrolls the timeline. Search highlights appear on the waveform/VAD canvases. +- **Bottom right**: minimap showing the full file duration. The blue rectangle + indicates the current viewport; drag to navigate. + +### Keyboard shortcuts + +| Key | Action | +|-----|--------| +| Space | Play / Pause | +| F | Search (focus search box) | +| Enter / Shift+Enter | Next / Previous search result | +| +/- | Zoom in / out | +| Left / Right | Pan | +| 0 | Merged (all channels) view | +| 1-9 | Select channel | + +## Implementation Phases + +### Phase 1 — Scaffold + waveform + +- Vite project setup, HTML shell, file drop zone. +- WAV decode via `AudioContext.decodeAudioData`. +- LOD pyramid builder (Web Worker). +- Canvas waveform renderer with pan/zoom. +- Channel selector (individual + "All" merged view). +- Audio playback with seek. + +### Phase 2 — VAD + ASR + +- `.npy` parser (typed array). +- VAD probability canvas, synced to waveform timeline. +- Threshold line (draggable or input). +- ASR JSON loader, transcript panel. +- Click sentence to seek. + +### Phase 3 — Search + polish + +- ASR text search with highlight on timeline. +- Prev/Next navigation. +- Minimap overview bar. +- Keyboard shortcuts. +- Responsive layout, loading indicators, error handling. + +### Phase 4 — Spectrogram + +- FFT Web Worker with tile caching. +- Spectrogram canvas, synced timeline. +- Color map (e.g. viridis or magma). From e89af50cf4bf067b61a1f89da04693f58096ebb8 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 11:28:19 +1200 Subject: [PATCH 15/36] feat: add audio viewer (Phases 1-3) Browser-based tool for inspecting WAV audio alongside VAD probabilities and ASR transcriptions. Includes waveform with LOD decimation, VAD hysteresis display, ASR transcript panel with search, minimap, playback, and keyboard shortcuts. Co-Authored-By: Claude Opus 4.6 (1M context) --- .gitignore | 6 +- training/smart-turn-zh/Makefile | 9 +- training/smart-turn-zh/viewer/README.md | 56 + training/smart-turn-zh/viewer/index.html | 54 + .../smart-turn-zh/viewer/package-lock.json | 1119 +++++++++++++++++ training/smart-turn-zh/viewer/package.json | 15 + training/smart-turn-zh/viewer/src/asr.ts | 129 ++ training/smart-turn-zh/viewer/src/audio.ts | 171 +++ training/smart-turn-zh/viewer/src/main.ts | 381 ++++++ training/smart-turn-zh/viewer/src/style.css | 288 +++++ training/smart-turn-zh/viewer/src/timeline.ts | 67 + training/smart-turn-zh/viewer/src/vad.ts | 138 ++ training/smart-turn-zh/viewer/src/waveform.ts | 121 ++ training/smart-turn-zh/viewer/tsconfig.json | 15 + training/smart-turn-zh/viewer/vite.config.ts | 5 + 15 files changed, 2572 insertions(+), 2 deletions(-) create mode 100644 training/smart-turn-zh/viewer/README.md create mode 100644 training/smart-turn-zh/viewer/index.html create mode 100644 training/smart-turn-zh/viewer/package-lock.json create mode 100644 training/smart-turn-zh/viewer/package.json create mode 100644 training/smart-turn-zh/viewer/src/asr.ts create mode 100644 training/smart-turn-zh/viewer/src/audio.ts create mode 100644 training/smart-turn-zh/viewer/src/main.ts create mode 100644 training/smart-turn-zh/viewer/src/style.css create mode 100644 training/smart-turn-zh/viewer/src/timeline.ts create mode 100644 training/smart-turn-zh/viewer/src/vad.ts create mode 100644 training/smart-turn-zh/viewer/src/waveform.ts create mode 100644 training/smart-turn-zh/viewer/tsconfig.json create mode 100644 training/smart-turn-zh/viewer/vite.config.ts diff --git a/.gitignore b/.gitignore index 081d9f3..342a923 100644 --- a/.gitignore +++ b/.gitignore @@ -28,4 +28,8 @@ training/smart-turn-zh/data/vad_probs/ training/smart-turn-zh/data/asr_results/ # Training references -training/smart-turn-zh/refs/*.pdf \ No newline at end of file +training/smart-turn-zh/refs/*.pdf + +# Viewer +training/smart-turn-zh/viewer/node_modules/ +training/smart-turn-zh/viewer/dist/ \ No newline at end of file diff --git a/training/smart-turn-zh/Makefile b/training/smart-turn-zh/Makefile index b7a4a6d..b1302a9 100644 --- a/training/smart-turn-zh/Makefile +++ b/training/smart-turn-zh/Makefile @@ -2,13 +2,14 @@ VENV := .venv PYTHON := $(VENV)/bin/python PIP := $(VENV)/bin/pip -.PHONY: help venv install notebook clean +.PHONY: help venv install notebook viewer clean help: @echo "Available targets:" @echo " venv Create virtualenv and install dependencies" @echo " install Re-install dependencies into existing venv" @echo " notebook Launch Jupyter notebook server" + @echo " viewer Launch audio viewer dev server" @echo " clean Remove virtualenv" venv: $(VENV)/bin/activate @@ -25,5 +26,11 @@ install: venv notebook: venv $(VENV)/bin/jupyter lab notebooks/ +viewer: viewer/node_modules + cd viewer && npm run dev + +viewer/node_modules: viewer/package.json + cd viewer && npm install + clean: rm -rf $(VENV) diff --git a/training/smart-turn-zh/viewer/README.md b/training/smart-turn-zh/viewer/README.md new file mode 100644 index 0000000..2ad4db7 --- /dev/null +++ b/training/smart-turn-zh/viewer/README.md @@ -0,0 +1,56 @@ +# Audio Viewer + +Browser-based tool for reviewing audio alongside VAD probabilities and ASR +transcriptions. Built to support the Smart Turn training data pipeline — lets +you visually inspect and cross-reference the outputs of the ASR and VAD +notebooks before feeding data into downstream labelling and training steps. + +## What it does + +- **Waveform display** with LOD decimation — handles 1-hour, multi-channel + recordings smoothly. Switch between individual channels or a merged "All" view. +- **VAD probability curve** with dual-threshold hysteresis (entry/exit), + color-coded active/inactive speech regions. +- **ASR transcript panel** with timestamped sentence list. Click any sentence + to jump to that moment. +- **Text search** across ASR results with timeline highlighting and + Previous/Next navigation. +- **Audio playback** with click-to-seek, keyboard shortcuts, and auto-scroll. +- **Minimap** overview bar for quick navigation across long recordings. + +All processing is client-side — drop your files in and go, no server needed. + +## Quick start + +```bash +npm install +npm run dev +``` + +Then open the URL shown in the terminal. Drop in your files: + +| File type | Example | Source | +|-----------|---------|--------| +| `.wav` | `R8001_M8004_MS801.wav` | `data/wav/` | +| `.npy` | `R8001_M8004_MS801.npy` | `data/vad_probs/` (from `02-vad.ipynb`) | +| `.json` | `R8001_M8004_MS801.json` | `data/asr_results/` (from `01-asr-transcribe.ipynb`) | + +## Keyboard shortcuts + +| Key | Action | +|-----|--------| +| Space | Play / Pause | +| F | Focus search box | +| Enter / Shift+Enter | Next / Previous search result | +| +/- | Zoom in / out | +| Left / Right | Pan | +| 0 | Merged (all channels) view | +| 1-9 | Select channel | + +## Further reading + +- [`docs/02-data-structures.md`](../docs/02-data-structures.md) — schemas for + the WAV, ASR, and VAD data formats this viewer consumes. +- [`docs/03-audio-viewer.md`](../docs/03-audio-viewer.md) — full design plan, + architecture decisions, and performance strategy. +- [`notebooks/`](../notebooks/) — the pipeline notebooks that produce the data. diff --git a/training/smart-turn-zh/viewer/index.html b/training/smart-turn-zh/viewer/index.html new file mode 100644 index 0000000..552d102 --- /dev/null +++ b/training/smart-turn-zh/viewer/index.html @@ -0,0 +1,54 @@ + + + + + + Audio Viewer + + +
+
+
+ + + +
+
+ + + --:-- / --:-- +
+
+ +
+
+ Waveform + +
+
+ VAD + +
+ + +
+
+
+ + + +
+ +
+
+
+ + + + + diff --git a/training/smart-turn-zh/viewer/package-lock.json b/training/smart-turn-zh/viewer/package-lock.json new file mode 100644 index 0000000..a8ce64d --- /dev/null +++ b/training/smart-turn-zh/viewer/package-lock.json @@ -0,0 +1,1119 @@ +{ + "name": "audio-viewer", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "audio-viewer", + "version": "0.1.0", + "devDependencies": { + "typescript": "^5.7.0", + "vite": "^6.0.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz", + "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz", + "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz", + "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz", + "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz", + "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz", + "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz", + "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz", + "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz", + "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz", + "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz", + "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz", + "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz", + "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz", + "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz", + "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz", + "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz", + "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz", + "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz", + "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz", + "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz", + "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz", + "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz", + "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz", + "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz", + "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz", + "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.2.tgz", + "integrity": "sha512-dnlp69efPPg6Uaw2dVqzWRfAWRnYVb1XJ8CyyhIbZeaq4CA5/mLeZ1IEt9QqQxmbdvagjLIm2ZL8BxXv5lH4Yw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.2.tgz", + "integrity": "sha512-OqZTwDRDchGRHHm/hwLOL7uVPB9aUvI0am/eQuWMNyFHf5PSEQmyEeYYheA0EPPKUO/l0uigCp+iaTjoLjVoHg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.2.tgz", + "integrity": "sha512-UwRE7CGpvSVEQS8gUMBe1uADWjNnVgP3Iusyda1nSRwNDCsRjnGc7w6El6WLQsXmZTbLZx9cecegumcitNfpmA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.2.tgz", + "integrity": "sha512-gjEtURKLCC5VXm1I+2i1u9OhxFsKAQJKTVB8WvDAHF+oZlq0GTVFOlTlO1q3AlCTE/DF32c16ESvfgqR7343/g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.2.tgz", + "integrity": "sha512-Bcl6CYDeAgE70cqZaMojOi/eK63h5Me97ZqAQoh77VPjMysA/4ORQBRGo3rRy45x4MzVlU9uZxs8Uwy7ZaKnBw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.2.tgz", + "integrity": "sha512-LU+TPda3mAE2QB0/Hp5VyeKJivpC6+tlOXd1VMoXV/YFMvk/MNk5iXeBfB4MQGRWyOYVJ01625vjkr0Az98OJQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.2.tgz", + "integrity": "sha512-2QxQrM+KQ7DAW4o22j+XZ6RKdxjLD7BOWTP0Bv0tmjdyhXSsr2Ul1oJDQqh9Zf5qOwTuTc7Ek83mOFaKnodPjg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.2.tgz", + "integrity": "sha512-TbziEu2DVsTEOPif2mKWkMeDMLoYjx95oESa9fkQQK7r/Orta0gnkcDpzwufEcAO2BLBsD7mZkXGFqEdMRRwfw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.2.tgz", + "integrity": "sha512-bO/rVDiDUuM2YfuCUwZ1t1cP+/yqjqz+Xf2VtkdppefuOFS2OSeAfgafaHNkFn0t02hEyXngZkxtGqXcXwO8Rg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.2.tgz", + "integrity": "sha512-hr26p7e93Rl0Za+JwW7EAnwAvKkehh12BU1Llm9Ykiibg4uIr2rbpxG9WCf56GuvidlTG9KiiQT/TXT1yAWxTA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.2.tgz", + "integrity": "sha512-pOjB/uSIyDt+ow3k/RcLvUAOGpysT2phDn7TTUB3n75SlIgZzM6NKAqlErPhoFU+npgY3/n+2HYIQVbF70P9/A==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.2.tgz", + "integrity": "sha512-2/w+q8jszv9Ww1c+6uJT3OwqhdmGP2/4T17cu8WuwyUuuaCDDJ2ojdyYwZzCxx0GcsZBhzi3HmH+J5pZNXnd+Q==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.2.tgz", + "integrity": "sha512-11+aL5vKheYgczxtPVVRhdptAM2H7fcDR5Gw4/bTcteuZBlH4oP9f5s9zYO9aGZvoGeBpqXI/9TZZihZ609wKw==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.2.tgz", + "integrity": "sha512-i16fokAGK46IVZuV8LIIwMdtqhin9hfYkCh8pf8iC3QU3LpwL+1FSFGej+O7l3E/AoknL6Dclh2oTdnRMpTzFQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.2.tgz", + "integrity": "sha512-49FkKS6RGQoriDSK/6E2GkAsAuU5kETFCh7pG4yD/ylj9rKhTmO3elsnmBvRD4PgJPds5W2PkhC82aVwmUcJ7A==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.2.tgz", + "integrity": "sha512-mjYNkHPfGpUR00DuM1ZZIgs64Hpf4bWcz9Z41+4Q+pgDx73UwWdAYyf6EG/lRFldmdHHzgrYyge5akFUW0D3mQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.2.tgz", + "integrity": "sha512-ALyvJz965BQk8E9Al/JDKKDLH2kfKFLTGMlgkAbbYtZuJt9LU8DW3ZoDMCtQpXAltZxwBHevXz5u+gf0yA0YoA==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.2.tgz", + "integrity": "sha512-UQjrkIdWrKI626Du8lCQ6MJp/6V1LAo2bOK9OTu4mSn8GGXIkPXk/Vsp4bLHCd9Z9Iz2OTEaokUE90VweJgIYQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.2.tgz", + "integrity": "sha512-bTsRGj6VlSdn/XD4CGyzMnzaBs9bsRxy79eTqTCBsA8TMIEky7qg48aPkvJvFe1HyzQ5oMZdg7AnVlWQSKLTnw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.2.tgz", + "integrity": "sha512-6d4Z3534xitaA1FcMWP7mQPq5zGwBmGbhphh2DwaA1aNIXUu3KTOfwrWpbwI4/Gr0uANo7NTtaykFyO2hPuFLg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.2.tgz", + "integrity": "sha512-NetAg5iO2uN7eB8zE5qrZ3CSil+7IJt4WDFLcC75Ymywq1VZVD6qJ6EvNLjZ3rEm6gB7XW5JdT60c6MN35Z85Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.2.tgz", + "integrity": "sha512-NCYhOotpgWZ5kdxCZsv6Iudx0wX8980Q/oW4pNFNihpBKsDbEA1zpkfxJGC0yugsUuyDZ7gL37dbzwhR0VI7pQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.2.tgz", + "integrity": "sha512-RXsaOqXxfoUBQoOgvmmijVxJnW2IGB0eoMO7F8FAjaj0UTywUO/luSqimWBJn04WNgUkeNhh7fs7pESXajWmkg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.2.tgz", + "integrity": "sha512-qdAzEULD+/hzObedtmV6iBpdL5TIbKVztGiK7O3/KYSf+HIzU257+MX1EXJcyIiDbMAqmbwaufcYPvyRryeZtA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.2.tgz", + "integrity": "sha512-Nd/SgG27WoA9e+/TdK74KnHz852TLa94ovOYySo/yMPuTmpckK/jIF2jSwS3g7ELSKXK13/cVdmg1Z/DaCWKxA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true, + "license": "MIT" + }, + "node_modules/esbuild": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz", + "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.25.12", + "@esbuild/android-arm": "0.25.12", + "@esbuild/android-arm64": "0.25.12", + "@esbuild/android-x64": "0.25.12", + "@esbuild/darwin-arm64": "0.25.12", + "@esbuild/darwin-x64": "0.25.12", + "@esbuild/freebsd-arm64": "0.25.12", + "@esbuild/freebsd-x64": "0.25.12", + "@esbuild/linux-arm": "0.25.12", + "@esbuild/linux-arm64": "0.25.12", + "@esbuild/linux-ia32": "0.25.12", + "@esbuild/linux-loong64": "0.25.12", + "@esbuild/linux-mips64el": "0.25.12", + "@esbuild/linux-ppc64": "0.25.12", + "@esbuild/linux-riscv64": "0.25.12", + "@esbuild/linux-s390x": "0.25.12", + "@esbuild/linux-x64": "0.25.12", + "@esbuild/netbsd-arm64": "0.25.12", + "@esbuild/netbsd-x64": "0.25.12", + "@esbuild/openbsd-arm64": "0.25.12", + "@esbuild/openbsd-x64": "0.25.12", + "@esbuild/openharmony-arm64": "0.25.12", + "@esbuild/sunos-x64": "0.25.12", + "@esbuild/win32-arm64": "0.25.12", + "@esbuild/win32-ia32": "0.25.12", + "@esbuild/win32-x64": "0.25.12" + } + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz", + "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.10", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.10.tgz", + "integrity": "sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/rollup": { + "version": "4.60.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.2.tgz", + "integrity": "sha512-J9qZyW++QK/09NyN/zeO0dG/1GdGfyp9lV8ajHnRVLfo/uFsbji5mHnDgn/qYdUHyCkM2N+8VyspgZclfAh0eQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.60.2", + "@rollup/rollup-android-arm64": "4.60.2", + "@rollup/rollup-darwin-arm64": "4.60.2", + "@rollup/rollup-darwin-x64": "4.60.2", + "@rollup/rollup-freebsd-arm64": "4.60.2", + "@rollup/rollup-freebsd-x64": "4.60.2", + "@rollup/rollup-linux-arm-gnueabihf": "4.60.2", + "@rollup/rollup-linux-arm-musleabihf": "4.60.2", + "@rollup/rollup-linux-arm64-gnu": "4.60.2", + "@rollup/rollup-linux-arm64-musl": "4.60.2", + "@rollup/rollup-linux-loong64-gnu": "4.60.2", + "@rollup/rollup-linux-loong64-musl": "4.60.2", + "@rollup/rollup-linux-ppc64-gnu": "4.60.2", + "@rollup/rollup-linux-ppc64-musl": "4.60.2", + "@rollup/rollup-linux-riscv64-gnu": "4.60.2", + "@rollup/rollup-linux-riscv64-musl": "4.60.2", + "@rollup/rollup-linux-s390x-gnu": "4.60.2", + "@rollup/rollup-linux-x64-gnu": "4.60.2", + "@rollup/rollup-linux-x64-musl": "4.60.2", + "@rollup/rollup-openbsd-x64": "4.60.2", + "@rollup/rollup-openharmony-arm64": "4.60.2", + "@rollup/rollup-win32-arm64-msvc": "4.60.2", + "@rollup/rollup-win32-ia32-msvc": "4.60.2", + "@rollup/rollup-win32-x64-gnu": "4.60.2", + "@rollup/rollup-win32-x64-msvc": "4.60.2", + "fsevents": "~2.3.2" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.16", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz", + "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/vite": { + "version": "6.4.2", + "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.2.tgz", + "integrity": "sha512-2N/55r4JDJ4gdrCvGgINMy+HH3iRpNIz8K6SFwVsA+JbQScLiC+clmAxBgwiSPgcG9U15QmvqCGWzMbqda5zGQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.25.0", + "fdir": "^6.4.4", + "picomatch": "^4.0.2", + "postcss": "^8.5.3", + "rollup": "^4.34.9", + "tinyglobby": "^0.2.13" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "jiti": ">=1.21.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + } + } +} diff --git a/training/smart-turn-zh/viewer/package.json b/training/smart-turn-zh/viewer/package.json new file mode 100644 index 0000000..6c6fe6e --- /dev/null +++ b/training/smart-turn-zh/viewer/package.json @@ -0,0 +1,15 @@ +{ + "name": "audio-viewer", + "private": true, + "version": "0.1.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "tsc && vite build", + "preview": "vite preview" + }, + "devDependencies": { + "typescript": "^5.7.0", + "vite": "^6.0.0" + } +} diff --git a/training/smart-turn-zh/viewer/src/asr.ts b/training/smart-turn-zh/viewer/src/asr.ts new file mode 100644 index 0000000..c79fa2c --- /dev/null +++ b/training/smart-turn-zh/viewer/src/asr.ts @@ -0,0 +1,129 @@ +import type { Timeline } from './timeline'; + +export interface Sentence { + text: string; + start: number; // ms + end: number; // ms +} + +export class ASRPanel { + sentences: Sentence[] = []; + results: number[] = []; + resultIdx = -1; + + private query = ''; + private listEl: HTMLElement; + private countEl: HTMLElement; + + constructor( + container: HTMLElement, + private tl: Timeline, + ) { + this.listEl = container.querySelector('#transcript-list')!; + this.countEl = container.querySelector('#search-count')!; + } + + load(json: unknown[]) { + this.sentences = []; + for (const rec of json as Array<{ sentences?: Sentence[] }>) { + if (rec.sentences) { + for (const s of rec.sentences) { + this.sentences.push({ text: s.text ?? '', start: s.start, end: s.end }); + } + } + } + this.renderList(); + } + + search(q: string) { + this.query = q; + this.results = []; + this.resultIdx = -1; + if (q) { + const lower = q.toLowerCase(); + for (let i = 0; i < this.sentences.length; i++) { + if (this.sentences[i].text.toLowerCase().includes(lower)) { + this.results.push(i); + } + } + } + this.updateCount(); + this.renderList(); + if (this.results.length) this.goTo(0); + } + + next() { + if (!this.results.length) return; + this.goTo((this.resultIdx + 1) % this.results.length); + } + + prev() { + if (!this.results.length) return; + this.goTo((this.resultIdx - 1 + this.results.length) % this.results.length); + } + + /** Draw search-match highlights on a canvas. Call after waveform render. */ + drawOverlay(ctx: CanvasRenderingContext2D, w: number, h: number) { + if (!this.results.length) return; + const cur = this.resultIdx >= 0 ? this.results[this.resultIdx] : -1; + for (const idx of this.results) { + const s = this.sentences[idx]; + const x1 = this.tl.timeToX(s.start / 1000, w); + const x2 = this.tl.timeToX(s.end / 1000, w); + const left = Math.max(0, x1), right = Math.min(w, x2); + if (right <= left) continue; + ctx.fillStyle = idx === cur ? 'rgba(255,152,0,0.3)' : 'rgba(255,235,59,0.15)'; + ctx.fillRect(left, 0, right - left, h); + } + } + + private goTo(idx: number) { + this.resultIdx = idx; + const s = this.sentences[this.results[idx]]; + const startSec = s.start / 1000; + const endSec = s.end / 1000; + const span = this.tl.viewEnd - this.tl.viewStart; + const center = (startSec + endSec) / 2; + this.tl.setView(center - span / 2, center + span / 2); + this.tl.setCursor(startSec); + this.updateCount(); + this.renderList(); + const el = this.listEl.querySelector(`[data-idx="${this.results[idx]}"]`); + el?.scrollIntoView({ block: 'center', behavior: 'smooth' }); + } + + private updateCount() { + if (!this.query) { this.countEl.textContent = ''; return; } + this.countEl.textContent = this.results.length + ? `${this.resultIdx + 1}/${this.results.length}` + : 'No results'; + } + + renderList() { + const matchSet = new Set(this.results); + const curSent = this.resultIdx >= 0 ? this.results[this.resultIdx] : -1; + const re = this.query ? new RegExp(escRe(this.query), 'gi') : null; + let html = ''; + + for (let i = 0; i < this.sentences.length; i++) { + const s = this.sentences[i]; + const cls = i === curSent ? 'sentence current' + : matchSet.has(i) ? 'sentence match' : 'sentence'; + const time = fmtTime(s.start / 1000); + let txt = escHtml(s.text); + if (re && matchSet.has(i)) txt = txt.replace(re, '$&'); + html += `
` + + `${time}${txt}
`; + } + this.listEl.innerHTML = html; + } +} + +function fmtTime(sec: number): string { + const m = Math.floor(sec / 60); + const s = sec % 60; + return `${String(m).padStart(2, '0')}:${s.toFixed(1).padStart(4, '0')}`; +} + +function escRe(s: string) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); } +function escHtml(s: string) { return s.replace(/&/g, '&').replace(//g, '>'); } diff --git a/training/smart-turn-zh/viewer/src/audio.ts b/training/smart-turn-zh/viewer/src/audio.ts new file mode 100644 index 0000000..554e766 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/audio.ts @@ -0,0 +1,171 @@ +export interface LODLevel { + min: Float32Array; + max: Float32Array; + bucketSize: number; +} + +interface WavInfo { + channels: number; + sampleRate: number; + bitsPerSample: number; + dataOffset: number; + frames: number; +} + +export class AudioStore { + info: WavInfo | null = null; + raw: Int16Array | null = null; + channelCount = 0; + sampleRate = 16000; + duration = 0; + totalFrames = 0; + + private lodCache = new Map(); + + async load(file: File) { + const buffer = await file.arrayBuffer(); + this.info = parseWavHeader(buffer); + this.raw = new Int16Array( + buffer, + this.info.dataOffset, + this.info.frames * this.info.channels, + ); + this.channelCount = this.info.channels; + this.sampleRate = this.info.sampleRate; + this.totalFrames = this.info.frames; + this.duration = this.totalFrames / this.sampleRate; + this.lodCache.clear(); + } + + /** Read a single sample as float [-1, 1]. channel=-1 for merged average. */ + sample(frame: number, channel: number): number { + if (!this.raw || frame < 0 || frame >= this.totalFrames) return 0; + const nch = this.info!.channels; + if (channel === -1) { + let sum = 0; + for (let c = 0; c < nch; c++) sum += this.raw[frame * nch + c]; + return sum / nch / 32768; + } + return this.raw[frame * nch + channel] / 32768; + } + + getLOD(channel: number): LODLevel[] { + const cached = this.lodCache.get(channel); + if (cached) return cached; + const levels = this.buildLOD(channel); + this.lodCache.set(channel, levels); + return levels; + } + + /** Create a mono AudioBuffer for playback of one channel (or merged). */ + createAudioBuffer(channel: number): AudioBuffer | null { + if (!this.raw || !this.info) return null; + const ctx = new OfflineAudioContext(1, this.totalFrames, this.sampleRate); + const buf = ctx.createBuffer(1, this.totalFrames, this.sampleRate); + const out = buf.getChannelData(0); + const raw = this.raw; + const nch = this.info.channels; + + if (channel === -1) { + for (let i = 0; i < this.totalFrames; i++) { + let sum = 0; + for (let c = 0; c < nch; c++) sum += raw[i * nch + c]; + out[i] = sum / nch / 32768; + } + } else { + for (let i = 0; i < this.totalFrames; i++) { + out[i] = raw[i * nch + channel] / 32768; + } + } + return buf; + } + + private buildLOD(channel: number): LODLevel[] { + if (!this.raw || !this.info) return []; + const raw = this.raw; + const frames = this.totalFrames; + const nch = this.info.channels; + const levels: LODLevel[] = []; + + // First level: bucket size 256 + const B0 = 256; + const n0 = Math.ceil(frames / B0); + const min0 = new Float32Array(n0); + const max0 = new Float32Array(n0); + + for (let b = 0; b < n0; b++) { + const start = b * B0; + const end = Math.min(start + B0, frames); + let lo = Infinity, hi = -Infinity; + + if (channel === -1) { + for (let i = start; i < end; i++) { + let sum = 0; + for (let c = 0; c < nch; c++) sum += raw[i * nch + c]; + const v = sum / nch / 32768; + if (v < lo) lo = v; + if (v > hi) hi = v; + } + } else { + for (let i = start; i < end; i++) { + const v = raw[i * nch + channel] / 32768; + if (v < lo) lo = v; + if (v > hi) hi = v; + } + } + min0[b] = lo; + max0[b] = hi; + } + levels.push({ min: min0, max: max0, bucketSize: B0 }); + + // Coarser levels: each bucket = 4 from previous + while (levels[levels.length - 1].min.length > 512) { + const prev = levels[levels.length - 1]; + const F = 4; + const count = Math.ceil(prev.min.length / F); + const mn = new Float32Array(count); + const mx = new Float32Array(count); + for (let b = 0; b < count; b++) { + const s = b * F; + const e = Math.min(s + F, prev.min.length); + let lo = Infinity, hi = -Infinity; + for (let j = s; j < e; j++) { + if (prev.min[j] < lo) lo = prev.min[j]; + if (prev.max[j] > hi) hi = prev.max[j]; + } + mn[b] = lo; + mx[b] = hi; + } + levels.push({ min: mn, max: mx, bucketSize: prev.bucketSize * F }); + } + + return levels; + } +} + +function parseWavHeader(buffer: ArrayBuffer): WavInfo { + const view = new DataView(buffer); + const channels = view.getUint16(22, true); + const sampleRate = view.getUint32(24, true); + const bitsPerSample = view.getUint16(34, true); + + // Search for 'data' chunk + let offset = 12; + while (offset < buffer.byteLength - 8) { + const id = String.fromCharCode( + view.getUint8(offset), + view.getUint8(offset + 1), + view.getUint8(offset + 2), + view.getUint8(offset + 3), + ); + const size = view.getUint32(offset + 4, true); + if (id === 'data') { + const dataOffset = offset + 8; + const frames = size / (channels * (bitsPerSample / 8)); + return { channels, sampleRate, bitsPerSample, dataOffset, frames }; + } + offset += 8 + size; + if (offset % 2 !== 0) offset++; // WAV chunks are word-aligned + } + throw new Error('No data chunk found in WAV file'); +} diff --git a/training/smart-turn-zh/viewer/src/main.ts b/training/smart-turn-zh/viewer/src/main.ts new file mode 100644 index 0000000..8dd8321 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/main.ts @@ -0,0 +1,381 @@ +import { Timeline } from './timeline'; +import { AudioStore } from './audio'; +import { WaveformRenderer } from './waveform'; +import { VADRenderer } from './vad'; +import { ASRPanel } from './asr'; +import './style.css'; + +// --- State --- + +const tl = new Timeline(); +const audio = new AudioStore(); + +// --- DOM --- + +const $ = (id: string) => document.getElementById(id) as T; + +const wavInput = $('wav-input'); +const vadInput = $('vad-input'); +const asrInput = $('asr-input'); +const wavStatus = $('wav-status'); +const vadStatus = $('vad-status'); +const asrStatus = $('asr-status'); +const chSel = $('channel-select'); +const playBtn = $('play-btn'); +const timeDisp = $('time-display'); +const wfCanvas = $('waveform-canvas'); +const vadCanvas = $('vad-canvas'); +const mmCanvas = $('minimap-canvas'); +const searchIn = $('search-input'); +const prevBtn = $('prev-btn'); +const nextBtn = $('next-btn'); +const vadEntry = $('vad-entry'); +const vadExit = $('vad-exit'); +const dropEl = $('drop-overlay'); + +// --- Renderers --- + +const wf = new WaveformRenderer(wfCanvas, tl, audio); +const vad = new VADRenderer(vadCanvas, tl); +const asr = new ASRPanel($('asr-panel'), tl); + +// --- Playback --- + +let actx: AudioContext | null = null; +let srcNode: AudioBufferSourceNode | null = null; +let playing = false; +let playT0 = 0; +let playOff = 0; +let playBuf: AudioBuffer | null = null; +let playChannel = -1; + +function ensurePlayBuf(ch: number): AudioBuffer | null { + if (playBuf && playChannel === ch) return playBuf; + playBuf = audio.createAudioBuffer(ch); + playChannel = ch; + return playBuf; +} + +function play(offset: number) { + if (!audio.raw) return; + const buf = ensurePlayBuf(wf.channel); + if (!buf) return; + actx = new AudioContext({ sampleRate: audio.sampleRate }); + srcNode = actx.createBufferSource(); + srcNode.buffer = buf; + srcNode.connect(actx.destination); + srcNode.start(0, offset); + srcNode.onended = () => stop(); + playT0 = actx.currentTime; + playOff = offset; + playing = true; + playBtn.innerHTML = '▮▮'; + rafLoop(); +} + +function stop() { + if (srcNode) { + srcNode.onended = null; + try { srcNode.stop(); } catch { /* already stopped */ } + srcNode = null; + } + if (actx) { + tl.cursor = curTime(); + actx.close(); + actx = null; + } + playing = false; + playBtn.innerHTML = '▶'; + renderAll(); +} + +function curTime(): number { + if (!actx) return tl.cursor; + return playOff + (actx.currentTime - playT0); +} + +function rafLoop() { + if (!playing) return; + const t = curTime(); + if (t >= tl.duration) { stop(); return; } + tl.cursor = t; + // Auto-scroll when cursor exits viewport + if (t > tl.viewEnd) { + const span = tl.viewEnd - tl.viewStart; + tl.viewStart = t; + tl.viewEnd = t + span; + } + renderAll(); + requestAnimationFrame(rafLoop); +} + +// --- File loading --- + +wavInput.onchange = () => wavInput.files?.[0] && loadWav(wavInput.files[0]); +vadInput.onchange = () => vadInput.files?.[0] && loadVad(vadInput.files[0]); +asrInput.onchange = () => asrInput.files?.[0] && loadAsr(asrInput.files[0]); + +async function loadWav(f: File) { + wavStatus.textContent = '...'; + try { + await audio.load(f); + tl.sampleRate = audio.sampleRate; + tl.setDuration(audio.duration); + chSel.innerHTML = ''; + for (let i = 0; i < audio.channelCount; i++) { + chSel.innerHTML += ``; + } + chSel.disabled = false; + playBtn.disabled = false; + playBuf = null; + wavStatus.textContent = '\u2713'; + } catch (e) { + wavStatus.textContent = '\u2717'; + console.error(e); + } +} + +async function loadVad(f: File) { + vadStatus.textContent = '...'; + try { + vad.load(await f.arrayBuffer()); + vadStatus.textContent = '\u2713'; + renderAll(); + } catch (e) { + vadStatus.textContent = '\u2717'; + console.error(e); + } +} + +async function loadAsr(f: File) { + asrStatus.textContent = '...'; + try { + const json = JSON.parse(await f.text()); + asr.load(Array.isArray(json) ? json : [json]); + asrStatus.textContent = '\u2713'; + prevBtn.disabled = false; + nextBtn.disabled = false; + } catch (e) { + asrStatus.textContent = '\u2717'; + console.error(e); + } +} + +// --- Drag & drop --- + +document.ondragover = (e) => { e.preventDefault(); dropEl.hidden = false; }; +dropEl.ondragleave = () => { dropEl.hidden = true; }; +document.ondrop = (e) => { + e.preventDefault(); + dropEl.hidden = true; + for (const f of e.dataTransfer?.files ?? []) { + if (f.name.endsWith('.wav')) loadWav(f); + else if (f.name.endsWith('.npy')) loadVad(f); + else if (f.name.endsWith('.json')) loadAsr(f); + } +}; + +// --- Controls --- + +chSel.onchange = () => { + wf.channel = +chSel.value; + playBuf = null; + renderAll(); +}; + +playBtn.onclick = () => playing ? stop() : play(tl.cursor); + +vadEntry.oninput = () => { vad.entryThreshold = +vadEntry.value; renderAll(); }; +vadExit.oninput = () => { vad.exitThreshold = +vadExit.value; renderAll(); }; + +searchIn.oninput = () => { asr.search(searchIn.value); renderAll(); }; +prevBtn.onclick = () => { asr.prev(); renderAll(); }; +nextBtn.onclick = () => { asr.next(); renderAll(); }; + +// ASR sentence click to seek +$('transcript-list').onclick = (e) => { + const el = (e.target as HTMLElement).closest('.sentence') as HTMLElement | null; + if (!el) return; + const t = +el.dataset.start! / 1000; + tl.setCursor(t); + if (playing) { stop(); play(t); } +}; + +// --- Canvas interaction (pan / zoom / seek) --- + +for (const cvs of [wfCanvas, vadCanvas]) { + cvs.addEventListener('wheel', (e) => { + e.preventDefault(); + const rect = cvs.getBoundingClientRect(); + const frac = (e.clientX - rect.left) / rect.width; + tl.zoom(e.deltaY > 0 ? 1.25 : 0.8, frac); + }, { passive: false }); + + let drag = false, startX = 0, startVS = 0, moved = false; + + cvs.onmousedown = (e) => { + drag = true; moved = false; startX = e.clientX; startVS = tl.viewStart; + }; + window.addEventListener('mousemove', (e) => { + if (!drag) return; + const dx = e.clientX - startX; + if (Math.abs(dx) > 3) moved = true; + if (!moved) return; + const rect = cvs.getBoundingClientRect(); + const span = tl.viewEnd - tl.viewStart; + const dt = -(dx / rect.width) * span; + tl.setView(startVS + dt, startVS + dt + span); + }); + window.addEventListener('mouseup', (e) => { + if (!drag) return; + drag = false; + if (!moved) { + const rect = cvs.getBoundingClientRect(); + const t = tl.xToTime(e.clientX - rect.left, rect.width); + tl.setCursor(t); + if (playing) { stop(); play(t); } + } + }); +} + +// Minimap click to navigate +mmCanvas.onclick = (e) => { + const rect = mmCanvas.getBoundingClientRect(); + const frac = (e.clientX - rect.left) / rect.width; + const t = frac * tl.duration; + const span = tl.viewEnd - tl.viewStart; + tl.setView(t - span / 2, t + span / 2); +}; + +// --- Keyboard shortcuts --- + +document.onkeydown = (e) => { + // Let search input handle its own keys (except Escape) + if (e.target === searchIn && e.key !== 'Escape') { + if (e.key === 'Enter') { + e.preventDefault(); + e.shiftKey ? asr.prev() : asr.next(); + renderAll(); + } + return; + } + switch (e.key) { + case ' ': + e.preventDefault(); + playing ? stop() : play(tl.cursor); + break; + case 'f': + e.preventDefault(); + searchIn.focus(); + break; + case 'Escape': + searchIn.blur(); + break; + case '=': case '+': + tl.zoom(0.67, 0.5); + break; + case '-': + tl.zoom(1.5, 0.5); + break; + case 'ArrowLeft': + tl.pan(-(tl.viewEnd - tl.viewStart) * 0.1); + break; + case 'ArrowRight': + tl.pan((tl.viewEnd - tl.viewStart) * 0.1); + break; + case '0': + wf.channel = -1; chSel.value = '-1'; playBuf = null; renderAll(); + break; + default: + if (e.key >= '1' && e.key <= '9') { + const ch = +e.key - 1; + if (ch < audio.channelCount) { + wf.channel = ch; chSel.value = String(ch); playBuf = null; renderAll(); + } + } + } +}; + +// --- Render --- + +function renderAll() { + wf.render(); + vad.render(); + renderMinimap(); + + // ASR search overlay on waveform canvas + if (asr.results.length) { + const dpr = devicePixelRatio; + const w = wfCanvas.width / dpr; + const h = wfCanvas.height / dpr; + const ctx = wfCanvas.getContext('2d')!; + ctx.setTransform(dpr, 0, 0, dpr, 0, 0); + asr.drawOverlay(ctx, w, h); + } + + timeDisp.textContent = `${fmt(tl.cursor)} / ${fmt(tl.duration)}`; +} + +function renderMinimap() { + if (!audio.raw) return; + const dpr = devicePixelRatio; + const rect = mmCanvas.getBoundingClientRect(); + mmCanvas.width = rect.width * dpr; + mmCanvas.height = rect.height * dpr; + const ctx = mmCanvas.getContext('2d')!; + const w = rect.width, h = rect.height; + ctx.setTransform(dpr, 0, 0, dpr, 0, 0); + ctx.clearRect(0, 0, w, h); + + // Coarsest LOD waveform overview + const levels = audio.getLOD(wf.channel); + if (levels.length) { + const lv = levels[levels.length - 1]; + const mid = h / 2, amp = mid; + ctx.fillStyle = '#1e3a4a'; + ctx.beginPath(); + for (let x = 0; x < w; x++) { + const b = Math.min(Math.floor((x / w) * lv.max.length), lv.max.length - 1); + x === 0 ? ctx.moveTo(x, mid - lv.max[b] * amp) : ctx.lineTo(x, mid - lv.max[b] * amp); + } + for (let x = w - 1; x >= 0; x--) { + const b = Math.min(Math.floor((x / w) * lv.min.length), lv.min.length - 1); + ctx.lineTo(x, mid - lv.min[b] * amp); + } + ctx.closePath(); + ctx.fill(); + } + + // Viewport indicator + const x1 = (tl.viewStart / tl.duration) * w; + const x2 = (tl.viewEnd / tl.duration) * w; + ctx.fillStyle = 'rgba(79,195,247,0.15)'; + ctx.fillRect(x1, 0, x2 - x1, h); + ctx.strokeStyle = '#4fc3f7'; + ctx.lineWidth = 1; + ctx.strokeRect(x1 + 0.5, 0.5, x2 - x1 - 1, h - 1); +} + +function fmt(sec: number): string { + const m = Math.floor(sec / 60); + const s = sec % 60; + return `${String(m).padStart(2, '0')}:${s.toFixed(1).padStart(4, '0')}`; +} + +// --- Timeline update listener (batched via rAF) --- + +let renderPending = false; +tl.onUpdate(() => { + if (playing) return; // playback loop handles rendering + if (renderPending) return; + renderPending = true; + requestAnimationFrame(() => { renderPending = false; renderAll(); }); +}); + +// --- Resize --- + +const ro = new ResizeObserver(() => { wf.resize(); vad.resize(); renderAll(); }); +ro.observe(wfCanvas.parentElement!); +ro.observe(vadCanvas.parentElement!); +wf.resize(); +vad.resize(); diff --git a/training/smart-turn-zh/viewer/src/style.css b/training/smart-turn-zh/viewer/src/style.css new file mode 100644 index 0000000..d3f2a27 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/style.css @@ -0,0 +1,288 @@ +* { + margin: 0; + padding: 0; + box-sizing: border-box; +} + +body { + background: #1a1a2e; + color: #e0e0e0; + font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; + font-size: 13px; + overflow: hidden; + height: 100vh; +} + +#app { + display: flex; + flex-direction: column; + height: 100vh; +} + +/* ---- Toolbar ---- */ + +#toolbar { + display: flex; + align-items: center; + justify-content: space-between; + padding: 8px 12px; + background: #16213e; + border-bottom: 1px solid #2a2a4a; + gap: 12px; + flex-shrink: 0; +} + +#file-controls { + display: flex; + gap: 8px; +} + +.file-btn { + display: inline-flex; + align-items: center; + gap: 4px; + padding: 4px 10px; + background: #2a2a4a; + border-radius: 4px; + cursor: pointer; + font-size: 12px; + user-select: none; +} + +.file-btn:hover { + background: #3a3a5a; +} + +.status { + color: #888; + font-size: 11px; + min-width: 12px; + text-align: center; +} + +#playback-controls { + display: flex; + align-items: center; + gap: 8px; +} + +select, +button, +input[type='number'] { + background: #2a2a4a; + color: #e0e0e0; + border: 1px solid #3a3a5a; + border-radius: 4px; + padding: 4px 8px; + font-size: 12px; + cursor: pointer; +} + +button:hover:not(:disabled) { + background: #3a3a5a; +} + +button:disabled { + opacity: 0.4; + cursor: not-allowed; +} + +#time-display { + font-family: monospace; + font-size: 13px; + color: #aaa; + min-width: 120px; +} + +/* ---- Tracks ---- */ + +#tracks { + flex: 1; + display: flex; + flex-direction: column; + min-height: 0; +} + +.track { + position: relative; + flex: 1; + min-height: 80px; + border-bottom: 1px solid #2a2a4a; +} + +.track-label { + position: absolute; + top: 4px; + left: 8px; + font-size: 10px; + color: #555; + z-index: 1; + pointer-events: none; +} + +.track canvas { + width: 100%; + height: 100%; + display: block; + cursor: crosshair; +} + +#vad-track { + max-height: 120px; +} + +#vad-thresholds { + position: absolute; + top: 4px; + right: 8px; + display: flex; + gap: 8px; + font-size: 10px; + z-index: 1; +} + +#vad-thresholds label { + display: flex; + align-items: center; + gap: 4px; + color: #888; +} + +#vad-thresholds input[type='number'] { + width: 50px; + padding: 2px 4px; + font-size: 10px; +} + +/* ---- Minimap ---- */ + +#minimap-canvas { + width: 100%; + height: 30px; + display: block; + cursor: pointer; + background: #0f0f23; + border-bottom: 1px solid #2a2a4a; + flex-shrink: 0; +} + +/* ---- ASR Panel ---- */ + +#asr-panel { + display: flex; + flex-direction: column; + height: 220px; + flex-shrink: 0; +} + +#search-bar { + display: flex; + align-items: center; + gap: 6px; + padding: 6px 12px; + background: #16213e; + border-bottom: 1px solid #2a2a4a; + flex-shrink: 0; +} + +#search-input { + flex: 1; + background: #1a1a2e; + color: #e0e0e0; + border: 1px solid #3a3a5a; + border-radius: 4px; + padding: 4px 8px; + font-size: 12px; + outline: none; +} + +#search-input:focus { + border-color: #4fc3f7; +} + +#search-count { + font-size: 11px; + color: #888; + min-width: 60px; + text-align: center; +} + +#transcript-list { + flex: 1; + overflow-y: auto; + padding: 4px 0; +} + +.sentence { + padding: 3px 12px; + cursor: pointer; + display: flex; + gap: 8px; + line-height: 1.4; +} + +.sentence:hover { + background: rgba(79, 195, 247, 0.08); +} + +.sentence.match { + background: rgba(255, 235, 59, 0.08); +} + +.sentence.current { + background: rgba(255, 152, 0, 0.15); +} + +.sentence .time { + color: #666; + font-family: monospace; + font-size: 11px; + flex-shrink: 0; + min-width: 55px; + padding-top: 1px; +} + +.sentence .txt { + word-break: break-all; +} + +.sentence mark { + background: rgba(255, 235, 59, 0.4); + color: inherit; + border-radius: 2px; + padding: 0 1px; +} + +/* ---- Drop overlay ---- */ + +#drop-overlay { + position: fixed; + inset: 0; + background: rgba(79, 195, 247, 0.15); + display: flex; + align-items: center; + justify-content: center; + font-size: 24px; + color: #4fc3f7; + z-index: 100; + pointer-events: none; +} + +#drop-overlay[hidden] { + display: none; +} + +/* ---- Scrollbar ---- */ + +::-webkit-scrollbar { + width: 6px; +} + +::-webkit-scrollbar-track { + background: #1a1a2e; +} + +::-webkit-scrollbar-thumb { + background: #3a3a5a; + border-radius: 3px; +} diff --git a/training/smart-turn-zh/viewer/src/timeline.ts b/training/smart-turn-zh/viewer/src/timeline.ts new file mode 100644 index 0000000..ccf9d0a --- /dev/null +++ b/training/smart-turn-zh/viewer/src/timeline.ts @@ -0,0 +1,67 @@ +export class Timeline { + duration = 0; + viewStart = 0; + viewEnd = 1; + cursor = 0; + sampleRate = 16000; + + private listeners: Array<() => void> = []; + + setDuration(d: number) { + this.duration = d; + this.viewStart = 0; + this.viewEnd = d; + this.emit(); + } + + setView(start: number, end: number) { + const minSpan = 0.005; + let s = start, e = end; + if (e - s < minSpan) { + const mid = (s + e) / 2; + s = mid - minSpan / 2; + e = mid + minSpan / 2; + } + if (s < 0) { e -= s; s = 0; } + if (e > this.duration) { s -= e - this.duration; e = this.duration; } + if (s < 0) s = 0; + this.viewStart = s; + this.viewEnd = e; + this.emit(); + } + + setCursor(t: number) { + this.cursor = Math.max(0, Math.min(this.duration, t)); + this.emit(); + } + + zoom(factor: number, anchorFrac: number) { + const span = this.viewEnd - this.viewStart; + const anchor = this.viewStart + span * anchorFrac; + const newSpan = span * factor; + this.setView(anchor - newSpan * anchorFrac, anchor - newSpan * anchorFrac + newSpan); + } + + pan(deltaSec: number) { + const span = this.viewEnd - this.viewStart; + this.setView(this.viewStart + deltaSec, this.viewEnd + deltaSec); + } + + /** Convert time to x pixel position within width. */ + timeToX(t: number, width: number): number { + return ((t - this.viewStart) / (this.viewEnd - this.viewStart)) * width; + } + + /** Convert x pixel position to time. */ + xToTime(x: number, width: number): number { + return this.viewStart + (x / width) * (this.viewEnd - this.viewStart); + } + + onUpdate(fn: () => void) { + this.listeners.push(fn); + } + + private emit() { + for (const fn of this.listeners) fn(); + } +} diff --git a/training/smart-turn-zh/viewer/src/vad.ts b/training/smart-turn-zh/viewer/src/vad.ts new file mode 100644 index 0000000..7a5fdf8 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/vad.ts @@ -0,0 +1,138 @@ +import type { Timeline } from './timeline'; + +export class VADRenderer { + probs: Float32Array | null = null; + entryThreshold = 0.3; + exitThreshold = 0.1; + readonly frameSec = 0.032; // 32 ms per frame + + private ctx: CanvasRenderingContext2D; + + constructor( + private canvas: HTMLCanvasElement, + private tl: Timeline, + ) { + this.ctx = canvas.getContext('2d')!; + } + + load(buffer: ArrayBuffer) { + this.probs = parseNpy(buffer); + } + + resize() { + const dpr = devicePixelRatio; + const rect = this.canvas.getBoundingClientRect(); + this.canvas.width = rect.width * dpr; + this.canvas.height = rect.height * dpr; + } + + render() { + if (!this.probs) return; + const { ctx, canvas, tl, probs, frameSec } = this; + const dpr = devicePixelRatio; + const w = canvas.width / dpr; + const h = canvas.height / dpr; + + ctx.setTransform(dpr, 0, 0, dpr, 0, 0); + ctx.clearRect(0, 0, w, h); + + const vStart = tl.viewStart; + const vSpan = tl.viewEnd - vStart; + const startFrame = Math.max(0, Math.floor(vStart / frameSec) - 1); + const endFrame = Math.min(probs.length, Math.ceil(tl.viewEnd / frameSec) + 1); + + // Compute hysteresis state up to startFrame + let active = false; + for (let i = 0; i < startFrame; i++) { + if (!active && probs[i] >= this.entryThreshold) active = true; + else if (active && probs[i] <= this.exitThreshold) active = false; + } + + // Draw active/inactive regions + let regStart = startFrame; + let regActive = active; + + const fillRegion = (from: number, to: number, isActive: boolean) => { + const x1 = ((from * frameSec - vStart) / vSpan) * w; + const x2 = ((to * frameSec - vStart) / vSpan) * w; + const left = Math.max(0, x1), right = Math.min(w, x2); + if (right <= left) return; + ctx.fillStyle = isActive ? 'rgba(76,175,80,0.25)' : 'rgba(255,255,255,0.03)'; + ctx.fillRect(left, 0, right - left, h); + }; + + for (let i = startFrame; i < endFrame; i++) { + const was: boolean = active; + if (!active && probs[i] >= this.entryThreshold) active = true; + else if (active && probs[i] <= this.exitThreshold) active = false; + if (active !== was) { + fillRegion(regStart, i, regActive); + regStart = i; + regActive = active; + } + } + fillRegion(regStart, endFrame, regActive); + + // Probability curve + ctx.strokeStyle = '#4fc3f7'; + ctx.lineWidth = 1; + ctx.beginPath(); + let first = true; + for (let x = 0; x < w; x++) { + const t = vStart + (x / w) * vSpan; + const fi = Math.round(t / frameSec); + if (fi < 0 || fi >= probs.length) continue; + const y = h - probs[fi] * h; + if (first) { ctx.moveTo(x, y); first = false; } else ctx.lineTo(x, y); + } + ctx.stroke(); + + // Threshold lines + this.drawThresh(w, h, this.entryThreshold, '#ff9800', 'Entry'); + this.drawThresh(w, h, this.exitThreshold, '#f44336', 'Exit'); + + // Cursor + const cx = tl.timeToX(tl.cursor, w); + if (cx >= 0 && cx <= w) { + ctx.strokeStyle = '#ff5722'; + ctx.lineWidth = 1.5; + ctx.beginPath(); + ctx.moveTo(cx, 0); + ctx.lineTo(cx, h); + ctx.stroke(); + } + } + + private drawThresh(w: number, h: number, val: number, color: string, label: string) { + const y = h - val * h; + const { ctx } = this; + ctx.strokeStyle = color; + ctx.lineWidth = 1; + ctx.setLineDash([4, 4]); + ctx.beginPath(); + ctx.moveTo(0, y); + ctx.lineTo(w, y); + ctx.stroke(); + ctx.setLineDash([]); + ctx.fillStyle = color; + ctx.font = '10px monospace'; + ctx.fillText(`${label} ${val}`, 4, y - 3); + } +} + +function parseNpy(buf: ArrayBuffer): Float32Array { + const bytes = new Uint8Array(buf); + const major = bytes[6]; + let headerLen: number, dataOffset: number; + if (major <= 1) { + headerLen = new DataView(buf).getUint16(8, true); + dataOffset = 10 + headerLen; + } else { + headerLen = new DataView(buf).getUint32(8, true); + dataOffset = 12 + headerLen; + } + if (dataOffset % 4 !== 0) { + return new Float32Array(buf.slice(dataOffset)); + } + return new Float32Array(buf, dataOffset); +} diff --git a/training/smart-turn-zh/viewer/src/waveform.ts b/training/smart-turn-zh/viewer/src/waveform.ts new file mode 100644 index 0000000..c91cc33 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/waveform.ts @@ -0,0 +1,121 @@ +import type { Timeline } from './timeline'; +import type { AudioStore } from './audio'; + +export class WaveformRenderer { + channel = -1; // -1 = merged all channels + private ctx: CanvasRenderingContext2D; + + constructor( + private canvas: HTMLCanvasElement, + private tl: Timeline, + private audio: AudioStore, + ) { + this.ctx = canvas.getContext('2d')!; + } + + resize() { + const dpr = devicePixelRatio; + const rect = this.canvas.getBoundingClientRect(); + this.canvas.width = rect.width * dpr; + this.canvas.height = rect.height * dpr; + } + + render() { + if (!this.audio.raw) return; + const { ctx, canvas, tl, audio } = this; + const dpr = devicePixelRatio; + const w = canvas.width / dpr; + const h = canvas.height / dpr; + + ctx.setTransform(dpr, 0, 0, dpr, 0, 0); + ctx.clearRect(0, 0, w, h); + + // Center line + ctx.strokeStyle = '#333'; + ctx.lineWidth = 0.5; + ctx.beginPath(); + ctx.moveTo(0, h / 2); + ctx.lineTo(w, h / 2); + ctx.stroke(); + + const sr = audio.sampleRate; + const s0 = Math.floor(tl.viewStart * sr); + const s1 = Math.ceil(tl.viewEnd * sr); + const spp = (s1 - s0) / w; // samples per pixel + + if (spp <= 1) { + this.drawRaw(w, h, s0, s1); + } else { + this.drawLOD(w, h, s0, s1, spp); + } + + // Playback cursor + const cx = tl.timeToX(tl.cursor, w); + if (cx >= 0 && cx <= w) { + ctx.strokeStyle = '#ff5722'; + ctx.lineWidth = 1.5; + ctx.beginPath(); + ctx.moveTo(cx, 0); + ctx.lineTo(cx, h); + ctx.stroke(); + } + } + + private drawRaw(w: number, h: number, s0: number, s1: number) { + const { ctx, audio } = this; + const mid = h / 2, amp = mid * 0.95; + ctx.strokeStyle = '#4fc3f7'; + ctx.lineWidth = 1; + ctx.beginPath(); + for (let x = 0; x < w; x++) { + const idx = s0 + Math.round((x / w) * (s1 - s0)); + const y = mid - audio.sample(idx, this.channel) * amp; + x === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y); + } + ctx.stroke(); + } + + private drawLOD(w: number, h: number, s0: number, s1: number, spp: number) { + const levels = this.audio.getLOD(this.channel); + if (!levels.length) return; + + // Pick level where bucketSize <= samplesPerPixel + let lv = levels[0]; + for (const l of levels) { + if (l.bucketSize <= spp) lv = l; + else break; + } + + const { ctx } = this; + const mid = h / 2, amp = mid * 0.95; + const span = s1 - s0; + + ctx.fillStyle = '#4fc3f7'; + ctx.beginPath(); + + // Forward pass: max envelope + for (let x = 0; x < w; x++) { + const ss = s0 + (x / w) * span; + const se = ss + span / w; + const b0 = Math.max(0, Math.floor(ss / lv.bucketSize)); + const b1 = Math.min(Math.ceil(se / lv.bucketSize), lv.max.length); + let hi = -Infinity; + for (let b = b0; b < b1; b++) if (lv.max[b] > hi) hi = lv.max[b]; + if (!isFinite(hi)) hi = 0; + x === 0 ? ctx.moveTo(x, mid - hi * amp) : ctx.lineTo(x, mid - hi * amp); + } + // Backward pass: min envelope + for (let x = w - 1; x >= 0; x--) { + const ss = s0 + (x / w) * span; + const se = ss + span / w; + const b0 = Math.max(0, Math.floor(ss / lv.bucketSize)); + const b1 = Math.min(Math.ceil(se / lv.bucketSize), lv.min.length); + let lo = Infinity; + for (let b = b0; b < b1; b++) if (lv.min[b] < lo) lo = lv.min[b]; + if (!isFinite(lo)) lo = 0; + ctx.lineTo(x, mid - lo * amp); + } + ctx.closePath(); + ctx.fill(); + } +} diff --git a/training/smart-turn-zh/viewer/tsconfig.json b/training/smart-turn-zh/viewer/tsconfig.json new file mode 100644 index 0000000..6b4064d --- /dev/null +++ b/training/smart-turn-zh/viewer/tsconfig.json @@ -0,0 +1,15 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "ESNext", + "moduleResolution": "bundler", + "strict": true, + "isolatedModules": true, + "esModuleInterop": true, + "lib": ["ES2022", "DOM", "DOM.Iterable"], + "outDir": "dist", + "sourceMap": true, + "skipLibCheck": true + }, + "include": ["src"] +} diff --git a/training/smart-turn-zh/viewer/vite.config.ts b/training/smart-turn-zh/viewer/vite.config.ts new file mode 100644 index 0000000..4eb250e --- /dev/null +++ b/training/smart-turn-zh/viewer/vite.config.ts @@ -0,0 +1,5 @@ +import { defineConfig } from 'vite'; + +export default defineConfig({ + build: { outDir: 'dist' }, +}); From b3b8c10c6a1d99425df5dac7ed9cc5bd514c56d1 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 11:55:26 +1200 Subject: [PATCH 16/36] feat: viewer char-level timing, segments, dB scale, multi-file open - Per-character ASR timestamps with hover tooltips and click-to-seek - Karaoke-style character highlighting during playback - Sentence/character segment boundary lines on waveform - Click sentence in transcript to zoom-to-fit - Linear/dB waveform scale toggle - Single multi-file open button (WAV+NPY+JSON at once) - Scroll to pan, Cmd/Ctrl+scroll to zoom - Ignore data/example/ directory Co-Authored-By: Claude Opus 4.6 (1M context) --- .gitignore | 1 + training/smart-turn-zh/viewer/index.html | 11 +- training/smart-turn-zh/viewer/src/asr.ts | 235 ++++++++++++++++-- training/smart-turn-zh/viewer/src/main.ts | 69 +++-- training/smart-turn-zh/viewer/src/style.css | 40 ++- training/smart-turn-zh/viewer/src/waveform.ts | 23 +- 6 files changed, 336 insertions(+), 43 deletions(-) diff --git a/.gitignore b/.gitignore index 342a923..f93cf51 100644 --- a/.gitignore +++ b/.gitignore @@ -26,6 +26,7 @@ training/smart-turn-zh/data/wav/*.wav training/smart-turn-zh/data/*.jsonl training/smart-turn-zh/data/vad_probs/ training/smart-turn-zh/data/asr_results/ +training/smart-turn-zh/data/example/ # Training references training/smart-turn-zh/refs/*.pdf diff --git a/training/smart-turn-zh/viewer/index.html b/training/smart-turn-zh/viewer/index.html index 552d102..992a1df 100644 --- a/training/smart-turn-zh/viewer/index.html +++ b/training/smart-turn-zh/viewer/index.html @@ -9,9 +9,10 @@
- - - + + + +
@@ -23,6 +24,10 @@
Waveform +
+ + +
diff --git a/training/smart-turn-zh/viewer/src/asr.ts b/training/smart-turn-zh/viewer/src/asr.ts index c79fa2c..d8da225 100644 --- a/training/smart-turn-zh/viewer/src/asr.ts +++ b/training/smart-turn-zh/viewer/src/asr.ts @@ -1,9 +1,21 @@ import type { Timeline } from './timeline'; +export interface CharTiming { + char: string; + start: number; // ms, -1 for punctuation without timestamp + end: number; +} + export interface Sentence { text: string; start: number; // ms end: number; // ms + chars: CharTiming[]; +} + +interface RawSentence { + text: string; start: number; end: number; + raw_text?: string; timestamp?: number[][]; } export class ASRPanel { @@ -14,6 +26,8 @@ export class ASRPanel { private query = ''; private listEl: HTMLElement; private countEl: HTMLElement; + private activeCharEl: HTMLElement | null = null; + private activeCharRange: [number, number] = [-1, -1]; constructor( container: HTMLElement, @@ -25,10 +39,11 @@ export class ASRPanel { load(json: unknown[]) { this.sentences = []; - for (const rec of json as Array<{ sentences?: Sentence[] }>) { + for (const rec of json as Array<{ sentences?: RawSentence[] }>) { if (rec.sentences) { for (const s of rec.sentences) { - this.sentences.push({ text: s.text ?? '', start: s.start, end: s.end }); + const chars = buildChars(s.text ?? '', s.raw_text ?? '', s.timestamp ?? []); + this.sentences.push({ text: s.text ?? '', start: s.start, end: s.end, chars }); } } } @@ -62,6 +77,45 @@ export class ASRPanel { this.goTo((this.resultIdx - 1 + this.results.length) % this.results.length); } + /** Highlight the character at the given cursor time (karaoke). */ + highlightAt(timeMs: number) { + if (this.activeCharEl && timeMs >= this.activeCharRange[0] && timeMs < this.activeCharRange[1]) { + return; // still within current character + } + this.clearHighlight(); + + const si = this.findSentenceAt(timeMs); + if (si < 0) return; + + const s = this.sentences[si]; + let charIdx = -1; + for (let ci = 0; ci < s.chars.length; ci++) { + const c = s.chars[ci]; + if (c.start >= 0 && timeMs >= c.start && timeMs < c.end) { charIdx = ci; break; } + } + if (charIdx < 0) return; + + const sentEl = this.listEl.querySelector(`[data-idx="${si}"]`); + if (!sentEl) return; + const txtEl = sentEl.querySelector('.txt'); + if (!txtEl) return; + const el = txtEl.children[charIdx] as HTMLElement | undefined; + if (!el) return; + + el.classList.add('char-active'); + this.activeCharEl = el; + this.activeCharRange = [s.chars[charIdx].start, s.chars[charIdx].end]; + sentEl.scrollIntoView?.({ block: 'nearest', behavior: 'auto' }); + } + + clearHighlight() { + if (this.activeCharEl) { + this.activeCharEl.classList.remove('char-active'); + this.activeCharEl = null; + this.activeCharRange = [-1, -1]; + } + } + /** Draw search-match highlights on a canvas. Call after waveform render. */ drawOverlay(ctx: CanvasRenderingContext2D, w: number, h: number) { if (!this.results.length) return; @@ -77,18 +131,115 @@ export class ASRPanel { } } - private goTo(idx: number) { - this.resultIdx = idx; - const s = this.sentences[this.results[idx]]; + /** Draw ASR segment boundaries and text labels on the canvas. */ + drawLabels(ctx: CanvasRenderingContext2D, w: number, h: number) { + if (!this.sentences.length) return; + const vStart = this.tl.viewStart; + const vEnd = this.tl.viewEnd; + const vSpan = vEnd - vStart; + + const fontSize = 11; + ctx.font = `${fontSize}px monospace`; + ctx.textBaseline = 'top'; + const rowH = fontSize + 6; + const labelY = h - rowH; + + for (const s of this.sentences) { + const startSec = s.start / 1000; + const endSec = s.end / 1000; + if (endSec < vStart || startSec > vEnd) continue; + + const rawX1 = ((startSec - vStart) / vSpan) * w; + const rawX2 = ((endSec - vStart) / vSpan) * w; + const x1 = Math.max(0, rawX1); + const x2 = Math.min(w, rawX2); + const regionW = x2 - x1; + + // --- Sentence boundary lines (full height) --- + ctx.setLineDash([3, 3]); + ctx.lineWidth = 1; + ctx.strokeStyle = 'rgba(255, 235, 59, 0.4)'; + if (rawX1 >= 0 && rawX1 <= w) { + ctx.beginPath(); + ctx.moveTo(rawX1, 0); + ctx.lineTo(rawX1, h); + ctx.stroke(); + } + if (rawX2 >= 0 && rawX2 <= w) { + ctx.beginPath(); + ctx.moveTo(rawX2, 0); + ctx.lineTo(rawX2, h); + ctx.stroke(); + } + ctx.setLineDash([]); + + // --- Per-character segment lines when zoomed in --- + const perChar = s.chars.length > 0 && regionW / s.text.length > 10; + if (perChar) { + ctx.strokeStyle = 'rgba(255, 255, 255, 0.12)'; + ctx.lineWidth = 0.5; + let lastEndMs = s.start; + for (const c of s.chars) { + if (c.start < 0) continue; + const cx = ((c.start / 1000 - vStart) / vSpan) * w; + if (cx > x1 + 1 && cx <= x2) { + ctx.beginPath(); + ctx.moveTo(cx, 0); + ctx.lineTo(cx, h); + ctx.stroke(); + } + lastEndMs = c.end >= 0 ? c.end : lastEndMs; + } + } + + if (regionW < 4) continue; + + // --- Text label bar at bottom --- + ctx.fillStyle = 'rgba(0, 0, 0, 0.45)'; + ctx.fillRect(x1, labelY, regionW, rowH); + + // Clip text to region + ctx.save(); + ctx.beginPath(); + ctx.rect(x1 + 1, labelY, regionW - 2, rowH); + ctx.clip(); + + ctx.fillStyle = '#ddd'; + if (perChar) { + let lastEnd = s.start; + for (const c of s.chars) { + const cStart = c.start >= 0 ? c.start : lastEnd; + const cx = ((cStart / 1000 - vStart) / vSpan) * w; + ctx.fillText(c.char, cx + 1, labelY + 3); + if (c.end >= 0) lastEnd = c.end; + } + } else { + ctx.fillText(s.text, x1 + 2, labelY + 3); + } + + ctx.restore(); + } + } + + /** Zoom viewport to fit a sentence with some padding. */ + zoomToSentence(sentIdx: number) { + const s = this.sentences[sentIdx]; + if (!s) return; const startSec = s.start / 1000; const endSec = s.end / 1000; - const span = this.tl.viewEnd - this.tl.viewStart; - const center = (startSec + endSec) / 2; - this.tl.setView(center - span / 2, center + span / 2); + const dur = endSec - startSec; + const pad = dur * 0.15; // 15% padding on each side + this.tl.setView(startSec - pad, endSec + pad); this.tl.setCursor(startSec); + } + + private goTo(idx: number) { + this.resultIdx = idx; + const sentIdx = this.results[idx]; + this.zoomToSentence(sentIdx); this.updateCount(); this.renderList(); - const el = this.listEl.querySelector(`[data-idx="${this.results[idx]}"]`); + const el = this.listEl.querySelector(`[data-idx="${sentIdx}"]`); el?.scrollIntoView({ block: 'center', behavior: 'smooth' }); } @@ -100,9 +251,9 @@ export class ASRPanel { } renderList() { + this.clearHighlight(); const matchSet = new Set(this.results); const curSent = this.resultIdx >= 0 ? this.results[this.resultIdx] : -1; - const re = this.query ? new RegExp(escRe(this.query), 'gi') : null; let html = ''; for (let i = 0; i < this.sentences.length; i++) { @@ -110,13 +261,63 @@ export class ASRPanel { const cls = i === curSent ? 'sentence current' : matchSet.has(i) ? 'sentence match' : 'sentence'; const time = fmtTime(s.start / 1000); - let txt = escHtml(s.text); - if (re && matchSet.has(i)) txt = txt.replace(re, '$&'); + + const hlSet = this.query && matchSet.has(i) + ? matchHlSet(s.text, this.query) : null; + + let txtHtml = ''; + for (let ci = 0; ci < s.chars.length; ci++) { + const c = s.chars[ci]; + const hl = hlSet?.has(ci) ? ' search-hl' : ''; + const ch = escHtml(c.char); + if (c.start >= 0) { + txtHtml += `${ch}`; + } else { + txtHtml += `${ch}`; + } + } + html += `
` + - `${time}${txt}
`; + `${time}${txtHtml}
`; } this.listEl.innerHTML = html; } + + private findSentenceAt(timeMs: number): number { + for (let i = 0; i < this.sentences.length; i++) { + if (timeMs >= this.sentences[i].start && timeMs <= this.sentences[i].end) return i; + } + return -1; + } +} + +function buildChars(text: string, rawText: string, timestamps: number[][]): CharTiming[] { + const chars: CharTiming[] = []; + let ri = 0; + for (let i = 0; i < text.length; i++) { + if (ri < rawText.length && text[i] === rawText[ri]) { + const ts = timestamps[ri]; + chars.push({ char: text[i], start: ts?.[0] ?? -1, end: ts?.[1] ?? -1 }); + ri++; + } else { + chars.push({ char: text[i], start: -1, end: -1 }); + } + } + return chars; +} + +function matchHlSet(text: string, query: string): Set { + const set = new Set(); + const lower = text.toLowerCase(); + const q = query.toLowerCase(); + let pos = 0; + for (;;) { + const idx = lower.indexOf(q, pos); + if (idx === -1) break; + for (let i = idx; i < idx + q.length; i++) set.add(i); + pos = idx + 1; + } + return set; } function fmtTime(sec: number): string { @@ -125,5 +326,11 @@ function fmtTime(sec: number): string { return `${String(m).padStart(2, '0')}:${s.toFixed(1).padStart(4, '0')}`; } -function escRe(s: string) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); } +function fmtMs(ms: number): string { + const sec = ms / 1000; + const m = Math.floor(sec / 60); + const s = sec % 60; + return `${String(m).padStart(2, '0')}:${s.toFixed(2).padStart(5, '0')}`; +} + function escHtml(s: string) { return s.replace(/&/g, '&').replace(//g, '>'); } diff --git a/training/smart-turn-zh/viewer/src/main.ts b/training/smart-turn-zh/viewer/src/main.ts index 8dd8321..5af44fd 100644 --- a/training/smart-turn-zh/viewer/src/main.ts +++ b/training/smart-turn-zh/viewer/src/main.ts @@ -1,6 +1,6 @@ import { Timeline } from './timeline'; import { AudioStore } from './audio'; -import { WaveformRenderer } from './waveform'; +import { WaveformRenderer, type WaveformScale } from './waveform'; import { VADRenderer } from './vad'; import { ASRPanel } from './asr'; import './style.css'; @@ -14,9 +14,7 @@ const audio = new AudioStore(); const $ = (id: string) => document.getElementById(id) as T; -const wavInput = $('wav-input'); -const vadInput = $('vad-input'); -const asrInput = $('asr-input'); +const multiInput = $('multi-input'); const wavStatus = $('wav-status'); const vadStatus = $('vad-status'); const asrStatus = $('asr-status'); @@ -111,9 +109,15 @@ function rafLoop() { // --- File loading --- -wavInput.onchange = () => wavInput.files?.[0] && loadWav(wavInput.files[0]); -vadInput.onchange = () => vadInput.files?.[0] && loadVad(vadInput.files[0]); -asrInput.onchange = () => asrInput.files?.[0] && loadAsr(asrInput.files[0]); +multiInput.onchange = () => { + for (const f of multiInput.files ?? []) routeFile(f); +}; + +function routeFile(f: File) { + if (f.name.endsWith('.wav')) loadWav(f); + else if (f.name.endsWith('.npy')) loadVad(f); + else if (f.name.endsWith('.json')) loadAsr(f); +} async function loadWav(f: File) { wavStatus.textContent = '...'; @@ -168,11 +172,7 @@ dropEl.ondragleave = () => { dropEl.hidden = true; }; document.ondrop = (e) => { e.preventDefault(); dropEl.hidden = true; - for (const f of e.dataTransfer?.files ?? []) { - if (f.name.endsWith('.wav')) loadWav(f); - else if (f.name.endsWith('.npy')) loadVad(f); - else if (f.name.endsWith('.json')) loadAsr(f); - } + for (const f of e.dataTransfer?.files ?? []) routeFile(f); }; // --- Controls --- @@ -188,17 +188,35 @@ playBtn.onclick = () => playing ? stop() : play(tl.cursor); vadEntry.oninput = () => { vad.entryThreshold = +vadEntry.value; renderAll(); }; vadExit.oninput = () => { vad.exitThreshold = +vadExit.value; renderAll(); }; +// Waveform scale toggle +$('wf-scale').onclick = (e) => { + const btn = (e.target as HTMLElement).closest('.scale-btn') as HTMLElement | null; + if (!btn) return; + wf.scale = btn.dataset.scale as WaveformScale; + for (const b of $('wf-scale').querySelectorAll('.scale-btn')) b.classList.remove('active'); + btn.classList.add('active'); + renderAll(); +}; + searchIn.oninput = () => { asr.search(searchIn.value); renderAll(); }; prevBtn.onclick = () => { asr.prev(); renderAll(); }; nextBtn.onclick = () => { asr.next(); renderAll(); }; -// ASR sentence click to seek +// ASR click to seek (character-level or sentence-level) $('transcript-list').onclick = (e) => { const el = (e.target as HTMLElement).closest('.sentence') as HTMLElement | null; if (!el) return; - const t = +el.dataset.start! / 1000; + const sentIdx = +el.dataset.idx!; + + // Character click: seek to that character's time + const charEl = (e.target as HTMLElement).closest('.char') as HTMLElement | null; + const t = charEl ? +charEl.dataset.cs! / 1000 : +el.dataset.start! / 1000; + + // Zoom to fit the sentence + asr.zoomToSentence(sentIdx); tl.setCursor(t); if (playing) { stop(); play(t); } + renderAll(); }; // --- Canvas interaction (pan / zoom / seek) --- @@ -206,9 +224,16 @@ $('transcript-list').onclick = (e) => { for (const cvs of [wfCanvas, vadCanvas]) { cvs.addEventListener('wheel', (e) => { e.preventDefault(); - const rect = cvs.getBoundingClientRect(); - const frac = (e.clientX - rect.left) / rect.width; - tl.zoom(e.deltaY > 0 ? 1.25 : 0.8, frac); + if (e.metaKey || e.ctrlKey) { + // Cmd/Ctrl + scroll = zoom + const rect = cvs.getBoundingClientRect(); + const frac = (e.clientX - rect.left) / rect.width; + tl.zoom(e.deltaY > 0 ? 1.25 : 0.8, frac); + } else { + // Plain scroll = horizontal pan + const span = tl.viewEnd - tl.viewStart; + tl.pan((e.deltaY > 0 ? 0.15 : -0.15) * span); + } }, { passive: false }); let drag = false, startX = 0, startVS = 0, moved = false; @@ -303,16 +328,20 @@ function renderAll() { vad.render(); renderMinimap(); - // ASR search overlay on waveform canvas - if (asr.results.length) { + // ASR overlays on waveform canvas + if (asr.sentences.length) { const dpr = devicePixelRatio; const w = wfCanvas.width / dpr; const h = wfCanvas.height / dpr; const ctx = wfCanvas.getContext('2d')!; ctx.setTransform(dpr, 0, 0, dpr, 0, 0); - asr.drawOverlay(ctx, w, h); + if (asr.results.length) asr.drawOverlay(ctx, w, h); + asr.drawLabels(ctx, w, h); } + // Karaoke highlight + asr.highlightAt(tl.cursor * 1000); + timeDisp.textContent = `${fmt(tl.cursor)} / ${fmt(tl.duration)}`; } diff --git a/training/smart-turn-zh/viewer/src/style.css b/training/smart-turn-zh/viewer/src/style.css index d3f2a27..80fdee8 100644 --- a/training/smart-turn-zh/viewer/src/style.css +++ b/training/smart-turn-zh/viewer/src/style.css @@ -131,6 +131,27 @@ button:disabled { max-height: 120px; } +.scale-toggle { + position: absolute; + top: 4px; + right: 8px; + display: flex; + gap: 2px; + z-index: 1; +} + +.scale-btn { + padding: 2px 6px !important; + font-size: 10px !important; + border-radius: 3px !important; + opacity: 0.5; +} + +.scale-btn.active { + opacity: 1; + background: #3a3a5a !important; +} + #vad-thresholds { position: absolute; top: 4px; @@ -246,11 +267,24 @@ button:disabled { word-break: break-all; } -.sentence mark { +.sentence .txt .char { + cursor: pointer; + border-radius: 1px; + transition: background 0.1s; +} + +.sentence .txt .char:hover { + background: rgba(79, 195, 247, 0.25); +} + +.sentence .txt .char-active { + background: rgba(255, 152, 0, 0.55) !important; + color: #fff; +} + +.sentence .txt .search-hl { background: rgba(255, 235, 59, 0.4); - color: inherit; border-radius: 2px; - padding: 0 1px; } /* ---- Drop overlay ---- */ diff --git a/training/smart-turn-zh/viewer/src/waveform.ts b/training/smart-turn-zh/viewer/src/waveform.ts index c91cc33..662d321 100644 --- a/training/smart-turn-zh/viewer/src/waveform.ts +++ b/training/smart-turn-zh/viewer/src/waveform.ts @@ -1,8 +1,11 @@ import type { Timeline } from './timeline'; import type { AudioStore } from './audio'; +export type WaveformScale = 'linear' | 'dB'; + export class WaveformRenderer { channel = -1; // -1 = merged all channels + scale: WaveformScale = 'linear'; private ctx: CanvasRenderingContext2D; constructor( @@ -61,6 +64,19 @@ export class WaveformRenderer { } } + /** Map a linear amplitude [-1,1] to vertical position. */ + private mapY(v: number, mid: number, amp: number): number { + if (this.scale === 'dB') { + const sign = v < 0 ? -1 : 1; + const abs = Math.abs(v); + // -60 dB floor, map to 0..1 + const db = abs > 1e-6 ? 20 * Math.log10(abs) : -60; + const norm = Math.max(0, (db + 60) / 60); // 0 at -60dB, 1 at 0dB + return mid - sign * norm * amp; + } + return mid - v * amp; + } + private drawRaw(w: number, h: number, s0: number, s1: number) { const { ctx, audio } = this; const mid = h / 2, amp = mid * 0.95; @@ -69,7 +85,7 @@ export class WaveformRenderer { ctx.beginPath(); for (let x = 0; x < w; x++) { const idx = s0 + Math.round((x / w) * (s1 - s0)); - const y = mid - audio.sample(idx, this.channel) * amp; + const y = this.mapY(audio.sample(idx, this.channel), mid, amp); x === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y); } ctx.stroke(); @@ -102,7 +118,8 @@ export class WaveformRenderer { let hi = -Infinity; for (let b = b0; b < b1; b++) if (lv.max[b] > hi) hi = lv.max[b]; if (!isFinite(hi)) hi = 0; - x === 0 ? ctx.moveTo(x, mid - hi * amp) : ctx.lineTo(x, mid - hi * amp); + const y = this.mapY(hi, mid, amp); + x === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y); } // Backward pass: min envelope for (let x = w - 1; x >= 0; x--) { @@ -113,7 +130,7 @@ export class WaveformRenderer { let lo = Infinity; for (let b = b0; b < b1; b++) if (lv.min[b] < lo) lo = lv.min[b]; if (!isFinite(lo)) lo = 0; - ctx.lineTo(x, mid - lo * amp); + ctx.lineTo(x, this.mapY(lo, mid, amp)); } ctx.closePath(); ctx.fill(); From c997faf7cfecb25035764f33aa4b7ba1a6fda847 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 12:01:34 +1200 Subject: [PATCH 17/36] feat: dB default, dB grid lines, LOD-aligned zoom presets Co-Authored-By: Claude Opus 4.6 (1M context) --- training/smart-turn-zh/viewer/index.html | 12 ++++++++-- training/smart-turn-zh/viewer/src/main.ts | 16 ++++++++++++++ training/smart-turn-zh/viewer/src/style.css | 16 ++++++++++++++ training/smart-turn-zh/viewer/src/waveform.ts | 22 ++++++++++++++++++- 4 files changed, 63 insertions(+), 3 deletions(-) diff --git a/training/smart-turn-zh/viewer/index.html b/training/smart-turn-zh/viewer/index.html index 992a1df..8565309 100644 --- a/training/smart-turn-zh/viewer/index.html +++ b/training/smart-turn-zh/viewer/index.html @@ -14,6 +14,14 @@
+
+ + + + + + +
@@ -25,8 +33,8 @@
Waveform
- - + +
diff --git a/training/smart-turn-zh/viewer/src/main.ts b/training/smart-turn-zh/viewer/src/main.ts index 5af44fd..5439db5 100644 --- a/training/smart-turn-zh/viewer/src/main.ts +++ b/training/smart-turn-zh/viewer/src/main.ts @@ -198,6 +198,22 @@ $('wf-scale').onclick = (e) => { renderAll(); }; +// Zoom level presets +$('zoom-levels').onclick = (e) => { + const btn = (e.target as HTMLElement).closest('.zoom-btn') as HTMLElement | null; + if (!btn) return; + const span = +btn.dataset.span!; + if (span === 0) { + tl.setView(0, tl.duration); + } else { + const center = (tl.viewStart + tl.viewEnd) / 2; + tl.setView(center - span / 2, center + span / 2); + } + for (const b of $('zoom-levels').querySelectorAll('.zoom-btn')) b.classList.remove('active'); + btn.classList.add('active'); + renderAll(); +}; + searchIn.oninput = () => { asr.search(searchIn.value); renderAll(); }; prevBtn.onclick = () => { asr.prev(); renderAll(); }; nextBtn.onclick = () => { asr.next(); renderAll(); }; diff --git a/training/smart-turn-zh/viewer/src/style.css b/training/smart-turn-zh/viewer/src/style.css index 80fdee8..2be64ce 100644 --- a/training/smart-turn-zh/viewer/src/style.css +++ b/training/smart-turn-zh/viewer/src/style.css @@ -87,6 +87,22 @@ button:disabled { cursor: not-allowed; } +#zoom-levels { + display: flex; + gap: 3px; +} + +.zoom-btn { + padding: 3px 7px !important; + font-size: 11px !important; + min-width: 0 !important; +} + +.zoom-btn.active { + background: #3a3a5a !important; + color: #4fc3f7; +} + #time-display { font-family: monospace; font-size: 13px; diff --git a/training/smart-turn-zh/viewer/src/waveform.ts b/training/smart-turn-zh/viewer/src/waveform.ts index 662d321..64357f7 100644 --- a/training/smart-turn-zh/viewer/src/waveform.ts +++ b/training/smart-turn-zh/viewer/src/waveform.ts @@ -5,7 +5,7 @@ export type WaveformScale = 'linear' | 'dB'; export class WaveformRenderer { channel = -1; // -1 = merged all channels - scale: WaveformScale = 'linear'; + scale: WaveformScale = 'dB'; private ctx: CanvasRenderingContext2D; constructor( @@ -41,6 +41,26 @@ export class WaveformRenderer { ctx.lineTo(w, h / 2); ctx.stroke(); + // dB grid lines + if (this.scale === 'dB') { + const mid = h / 2, amp = mid * 0.95; + ctx.font = '9px monospace'; + ctx.textBaseline = 'middle'; + for (const db of [-6, -12, -24, -48]) { + const norm = Math.max(0, (db + 60) / 60); + const yUp = mid - norm * amp; + const yDn = mid + norm * amp; + ctx.strokeStyle = 'rgba(255,255,255,0.08)'; + ctx.lineWidth = 0.5; + ctx.beginPath(); + ctx.moveTo(0, yUp); ctx.lineTo(w, yUp); + ctx.moveTo(0, yDn); ctx.lineTo(w, yDn); + ctx.stroke(); + ctx.fillStyle = 'rgba(255,255,255,0.2)'; + ctx.fillText(`${db}`, 2, yUp); + } + } + const sr = audio.sampleRate; const s0 = Math.floor(tl.viewStart * sr); const s1 = Math.ceil(tl.viewEnd * sr); From e72be58bb17fd55e3eed34264488cd71e2e60a13 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 12:20:00 +1200 Subject: [PATCH 18/36] feat: volume control, gap highlighting, char label splits - Add gain slider (default 10x, max 20x) with real-time GainNode - Highlight gaps between char timestamps in red on waveform and label bar - Alternating char backgrounds in label bar for visual separation Co-Authored-By: Claude Opus 4.6 (1M context) --- training/smart-turn-zh/viewer/index.html | 1 + training/smart-turn-zh/viewer/src/asr.ts | 101 ++++++++++++++++++-- training/smart-turn-zh/viewer/src/main.ts | 15 ++- training/smart-turn-zh/viewer/src/style.css | 19 ++++ 4 files changed, 128 insertions(+), 8 deletions(-) diff --git a/training/smart-turn-zh/viewer/index.html b/training/smart-turn-zh/viewer/index.html index 8565309..9097be1 100644 --- a/training/smart-turn-zh/viewer/index.html +++ b/training/smart-turn-zh/viewer/index.html @@ -25,6 +25,7 @@
+ --:-- / --:--
diff --git a/training/smart-turn-zh/viewer/src/asr.ts b/training/smart-turn-zh/viewer/src/asr.ts index d8da225..244bb7f 100644 --- a/training/smart-turn-zh/viewer/src/asr.ts +++ b/training/smart-turn-zh/viewer/src/asr.ts @@ -144,7 +144,8 @@ export class ASRPanel { const rowH = fontSize + 6; const labelY = h - rowH; - for (const s of this.sentences) { + for (let si = 0; si < this.sentences.length; si++) { + const s = this.sentences[si]; const startSec = s.start / 1000; const endSec = s.end / 1000; if (endSec < vStart || startSec > vEnd) continue; @@ -155,6 +156,56 @@ export class ASRPanel { const x2 = Math.min(w, rawX2); const regionW = x2 - x1; + // --- Alternating sentence background (full height) --- + const sentColor = si % 2 === 0 + ? 'rgba(79, 195, 247, 0.06)' + : 'rgba(255, 183, 77, 0.06)'; + ctx.fillStyle = sentColor; + ctx.fillRect(x1, 0, regionW, labelY); + + // --- Per-character shading + gap highlighting when zoomed in --- + const perChar = s.chars.length > 0 && regionW / s.text.length > 10; + if (perChar) { + let ci = 0; + let prevEndMs = s.start; // track end of previous char to find gaps + for (const c of s.chars) { + if (c.start < 0) continue; + const cEndMs = c.end >= 0 ? c.end : c.start; + + // Gap before this character + if (c.start > prevEndMs) { + const gx1 = Math.max(0, ((prevEndMs / 1000 - vStart) / vSpan) * w); + const gx2 = Math.min(w, ((c.start / 1000 - vStart) / vSpan) * w); + if (gx2 > gx1) { + ctx.fillStyle = 'rgba(244, 67, 54, 0.12)'; + ctx.fillRect(gx1, 0, gx2 - gx1, labelY); + } + } + + // Character region + const cx1 = ((c.start / 1000 - vStart) / vSpan) * w; + const cx2 = ((cEndMs / 1000 - vStart) / vSpan) * w; + const cl = Math.max(0, cx1), cr = Math.min(w, cx2); + if (cr > cl) { + ctx.fillStyle = ci % 2 === 0 + ? 'rgba(79, 195, 247, 0.08)' + : 'rgba(255, 183, 77, 0.08)'; + ctx.fillRect(cl, 0, cr - cl, labelY); + } + prevEndMs = cEndMs; + ci++; + } + // Gap after last character to sentence end + if (prevEndMs < s.end) { + const gx1 = Math.max(0, ((prevEndMs / 1000 - vStart) / vSpan) * w); + const gx2 = Math.min(w, ((endSec - vStart) / vSpan) * w); + if (gx2 > gx1) { + ctx.fillStyle = 'rgba(244, 67, 54, 0.12)'; + ctx.fillRect(gx1, 0, gx2 - gx1, labelY); + } + } + } + // --- Sentence boundary lines (full height) --- ctx.setLineDash([3, 3]); ctx.lineWidth = 1; @@ -173,12 +224,10 @@ export class ASRPanel { } ctx.setLineDash([]); - // --- Per-character segment lines when zoomed in --- - const perChar = s.chars.length > 0 && regionW / s.text.length > 10; + // --- Per-character boundary lines when zoomed in --- if (perChar) { ctx.strokeStyle = 'rgba(255, 255, 255, 0.12)'; ctx.lineWidth = 0.5; - let lastEndMs = s.start; for (const c of s.chars) { if (c.start < 0) continue; const cx = ((c.start / 1000 - vStart) / vSpan) * w; @@ -188,15 +237,53 @@ export class ASRPanel { ctx.lineTo(cx, h); ctx.stroke(); } - lastEndMs = c.end >= 0 ? c.end : lastEndMs; } } if (regionW < 4) continue; // --- Text label bar at bottom --- - ctx.fillStyle = 'rgba(0, 0, 0, 0.45)'; - ctx.fillRect(x1, labelY, regionW, rowH); + if (perChar) { + // Alternating background per character + gap highlights + let ci = 0; + let prevEnd = s.start; + for (const c of s.chars) { + if (c.start < 0) continue; + const cEnd = c.end >= 0 ? c.end : c.start; + // Gap in label bar + if (c.start > prevEnd) { + const gx1 = Math.max(x1, ((prevEnd / 1000 - vStart) / vSpan) * w); + const gx2 = Math.min(x2, ((c.start / 1000 - vStart) / vSpan) * w); + if (gx2 > gx1) { + ctx.fillStyle = 'rgba(244, 67, 54, 0.35)'; + ctx.fillRect(gx1, labelY, gx2 - gx1, rowH); + } + } + // Character cell + const cx1c = Math.max(x1, ((c.start / 1000 - vStart) / vSpan) * w); + const cx2c = Math.min(x2, ((cEnd / 1000 - vStart) / vSpan) * w); + if (cx2c > cx1c) { + ctx.fillStyle = ci % 2 === 0 + ? 'rgba(30, 60, 80, 0.85)' + : 'rgba(50, 40, 30, 0.85)'; + ctx.fillRect(cx1c, labelY, cx2c - cx1c, rowH); + } + prevEnd = cEnd; + ci++; + } + // Trailing gap + if (prevEnd < s.end) { + const gx1 = Math.max(x1, ((prevEnd / 1000 - vStart) / vSpan) * w); + const gx2 = Math.min(x2, ((endSec - vStart) / vSpan) * w); + if (gx2 > gx1) { + ctx.fillStyle = 'rgba(244, 67, 54, 0.35)'; + ctx.fillRect(gx1, labelY, gx2 - gx1, rowH); + } + } + } else { + ctx.fillStyle = 'rgba(0, 0, 0, 0.45)'; + ctx.fillRect(x1, labelY, regionW, rowH); + } // Clip text to region ctx.save(); diff --git a/training/smart-turn-zh/viewer/src/main.ts b/training/smart-turn-zh/viewer/src/main.ts index 5439db5..e3e27c2 100644 --- a/training/smart-turn-zh/viewer/src/main.ts +++ b/training/smart-turn-zh/viewer/src/main.ts @@ -41,11 +41,15 @@ const asr = new ASRPanel($('asr-panel'), tl); let actx: AudioContext | null = null; let srcNode: AudioBufferSourceNode | null = null; +let gainNode: GainNode | null = null; let playing = false; let playT0 = 0; let playOff = 0; let playBuf: AudioBuffer | null = null; let playChannel = -1; +let gainValue = 10.0; +const gainSlider = $('gain-slider'); +const gainDisp = $('gain-value'); function ensurePlayBuf(ch: number): AudioBuffer | null { if (playBuf && playChannel === ch) return playBuf; @@ -59,9 +63,12 @@ function play(offset: number) { const buf = ensurePlayBuf(wf.channel); if (!buf) return; actx = new AudioContext({ sampleRate: audio.sampleRate }); + gainNode = actx.createGain(); + gainNode.gain.value = gainValue; + gainNode.connect(actx.destination); srcNode = actx.createBufferSource(); srcNode.buffer = buf; - srcNode.connect(actx.destination); + srcNode.connect(gainNode); srcNode.start(0, offset); srcNode.onended = () => stop(); playT0 = actx.currentTime; @@ -185,6 +192,12 @@ chSel.onchange = () => { playBtn.onclick = () => playing ? stop() : play(tl.cursor); +gainSlider.oninput = () => { + gainValue = +gainSlider.value; + gainDisp.textContent = `${gainValue.toFixed(1)}x`; + if (gainNode) gainNode.gain.value = gainValue; +}; + vadEntry.oninput = () => { vad.entryThreshold = +vadEntry.value; renderAll(); }; vadExit.oninput = () => { vad.exitThreshold = +vadExit.value; renderAll(); }; diff --git a/training/smart-turn-zh/viewer/src/style.css b/training/smart-turn-zh/viewer/src/style.css index 2be64ce..465be6b 100644 --- a/training/smart-turn-zh/viewer/src/style.css +++ b/training/smart-turn-zh/viewer/src/style.css @@ -103,6 +103,25 @@ button:disabled { color: #4fc3f7; } +#gain-label { + display: flex; + align-items: center; + gap: 4px; + font-size: 11px; + color: #888; +} + +#gain-slider { + width: 60px; + cursor: pointer; +} + +#gain-value { + font-family: monospace; + font-size: 11px; + min-width: 32px; +} + #time-display { font-family: monospace; font-size: 13px; From add1f9fa83eafa20702500aaa11a8c2fb0b195fe Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 12:33:05 +1200 Subject: [PATCH 19/36] chore: gitignore nested wav, notebook outputs Co-Authored-By: Claude Opus 4.6 (1M context) --- .gitignore | 1 + training/smart-turn-zh/notebooks/02-vad.ipynb | 15 ++------------- 2 files changed, 3 insertions(+), 13 deletions(-) diff --git a/.gitignore b/.gitignore index f93cf51..3ce980c 100644 --- a/.gitignore +++ b/.gitignore @@ -23,6 +23,7 @@ training/**/.venv/ # Training data training/smart-turn-zh/data/wav/*.wav +training/smart-turn-zh/data/**/*.wav training/smart-turn-zh/data/*.jsonl training/smart-turn-zh/data/vad_probs/ training/smart-turn-zh/data/asr_results/ diff --git a/training/smart-turn-zh/notebooks/02-vad.ipynb b/training/smart-turn-zh/notebooks/02-vad.ipynb index 23facf8..908efd2 100644 --- a/training/smart-turn-zh/notebooks/02-vad.ipynb +++ b/training/smart-turn-zh/notebooks/02-vad.ipynb @@ -92,20 +92,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Preview: plot speech probabilities\n", "import matplotlib.pyplot as plt\n", From 7f490345c2fc7bc99b691fe038fea4936d39583f Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 13:26:34 +1200 Subject: [PATCH 20/36] fix: remove file type filter from Open files picker Co-Authored-By: Claude Opus 4.6 (1M context) --- training/smart-turn-zh/viewer/index.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/training/smart-turn-zh/viewer/index.html b/training/smart-turn-zh/viewer/index.html index 9097be1..1aa333a 100644 --- a/training/smart-turn-zh/viewer/index.html +++ b/training/smart-turn-zh/viewer/index.html @@ -9,7 +9,7 @@
- + From 6e23612bd6330f7cf386ce92ec851e657791f406 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 13:27:36 +1200 Subject: [PATCH 21/36] chore: update notebook execution outputs Co-Authored-By: Claude Opus 4.6 (1M context) --- .../notebooks/01-asr-transcribe.ipynb | 7 +++++++ training/smart-turn-zh/notebooks/02-vad.ipynb | 14 ++++++++++++++ 2 files changed, 21 insertions(+) diff --git a/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb b/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb index 130bf11..2ec9166 100644 --- a/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb +++ b/training/smart-turn-zh/notebooks/01-asr-transcribe.ipynb @@ -131,6 +131,13 @@ " print()" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/training/smart-turn-zh/notebooks/02-vad.ipynb b/training/smart-turn-zh/notebooks/02-vad.ipynb index 908efd2..b3753f5 100644 --- a/training/smart-turn-zh/notebooks/02-vad.ipynb +++ b/training/smart-turn-zh/notebooks/02-vad.ipynb @@ -139,6 +139,20 @@ "plt.show()" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, From f04132f400371bfe2a78b67bcec6e3f61570a2b9 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 13:34:58 +1200 Subject: [PATCH 22/36] feat: add notebook to group wav/vad/asr for viewer Co-Authored-By: Claude Opus 4.6 (1M context) --- .gitignore | 1 + .../notebooks/03-group-for-viewer.ipynb | 152 ++++++++++++++++++ 2 files changed, 153 insertions(+) create mode 100644 training/smart-turn-zh/notebooks/03-group-for-viewer.ipynb diff --git a/.gitignore b/.gitignore index 3ce980c..d5a631f 100644 --- a/.gitignore +++ b/.gitignore @@ -28,6 +28,7 @@ training/smart-turn-zh/data/*.jsonl training/smart-turn-zh/data/vad_probs/ training/smart-turn-zh/data/asr_results/ training/smart-turn-zh/data/example/ +training/smart-turn-zh/data/grouped/ # Training references training/smart-turn-zh/refs/*.pdf diff --git a/training/smart-turn-zh/notebooks/03-group-for-viewer.ipynb b/training/smart-turn-zh/notebooks/03-group-for-viewer.ipynb new file mode 100644 index 0000000..ec1e857 --- /dev/null +++ b/training/smart-turn-zh/notebooks/03-group-for-viewer.ipynb @@ -0,0 +1,152 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Group Files for Viewer\n", + "\n", + "For each WAV in `data/wav/` that has a matching VAD `.npy` and ASR `.json`,\n", + "move all three into `data/grouped/{stem}/` so they can be opened together in the viewer." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import shutil\n", + "from pathlib import Path\n", + "\n", + "WAV_DIR = Path(\"../data/wav\")\n", + "VAD_DIR = Path(\"../data/vad_probs\")\n", + "ASR_DIR = Path(\"../data/asr_results\")\n", + "OUT_DIR = Path(\"../data/grouped\")\n", + "\n", + "OUT_DIR.mkdir(parents=True, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Ready to group: 0\n" + ] + } + ], + "source": [ + "# Preview — show what will be moved vs skipped\n", + "to_group = []\n", + "skipped = []\n", + "\n", + "for wav_path in sorted(WAV_DIR.glob(\"*.wav\")):\n", + " stem = wav_path.stem\n", + " vad_path = VAD_DIR / f\"{stem}.npy\"\n", + " asr_path = ASR_DIR / f\"{stem}.json\"\n", + "\n", + " if not vad_path.exists() or not asr_path.exists():\n", + " missing = []\n", + " if not vad_path.exists(): missing.append(\"VAD\")\n", + " if not asr_path.exists(): missing.append(\"ASR\")\n", + " skipped.append((stem, missing))\n", + " else:\n", + " to_group.append((wav_path, vad_path, asr_path))\n", + " print(f\" ✓ {stem}\")\n", + "\n", + "print(f\"\\nReady to group: {len(to_group)}\")\n", + "if skipped:\n", + " print(f\"Skipped: {len(skipped)}\")\n", + " for stem, missing in skipped:\n", + " print(f\" ✗ {stem} — missing {', '.join(missing)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Moved: 0\n" + ] + } + ], + "source": [ + "# Move files\n", + "for wav_path, vad_path, asr_path in to_group:\n", + " dest = OUT_DIR / wav_path.stem\n", + " dest.mkdir(exist_ok=True)\n", + "\n", + " shutil.move(str(wav_path), dest / wav_path.name)\n", + " shutil.move(str(vad_path), dest / vad_path.name)\n", + " shutil.move(str(asr_path), dest / asr_path.name)\n", + "\n", + " print(f\" {wav_path.stem}/\")\n", + "\n", + "print(f\"\\nMoved: {len(to_group)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R8001_M8004_N_SPK8013/ ['R8001_M8004_N_SPK8013.json', 'R8001_M8004_N_SPK8013.npy', 'R8001_M8004_N_SPK8013.wav']\n", + "R8001_M8004_N_SPK8014/ ['R8001_M8004_N_SPK8014.json', 'R8001_M8004_N_SPK8014.npy', 'R8001_M8004_N_SPK8014.wav']\n", + "R8001_M8004_N_SPK8015/ ['R8001_M8004_N_SPK8015.json', 'R8001_M8004_N_SPK8015.npy', 'R8001_M8004_N_SPK8015.wav']\n", + "R8001_M8004_N_SPK8016/ ['R8001_M8004_N_SPK8016.json', 'R8001_M8004_N_SPK8016.npy', 'R8001_M8004_N_SPK8016.wav']\n" + ] + } + ], + "source": [ + "# Verify\n", + "for d in sorted(OUT_DIR.iterdir()):\n", + " if d.is_dir():\n", + " files = sorted(f.name for f in d.iterdir())\n", + " print(f\"{d.name}/ {files}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From df559ef9d822672d413018c18376a3bf46a6496e Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 14:35:57 +1200 Subject: [PATCH 23/36] refactor: migrate viewer to React Co-Authored-By: Claude Opus 4.6 (1M context) --- training/smart-turn-zh/viewer/index.html | 60 +- .../smart-turn-zh/viewer/package-lock.json | 705 +++++++++++++++++- training/smart-turn-zh/viewer/package.json | 9 +- training/smart-turn-zh/viewer/src/App.tsx | 310 ++++++++ training/smart-turn-zh/viewer/src/asr.ts | 423 ----------- .../viewer/src/components/ASRPanel.tsx | 184 +++++ .../viewer/src/components/Minimap.tsx | 78 ++ .../viewer/src/components/Toolbar.tsx | 124 +++ .../viewer/src/components/VADTrack.tsx | 95 +++ .../viewer/src/components/WaveformTrack.tsx | 111 +++ .../viewer/src/hooks/useCanvasInteraction.ts | 68 ++ .../viewer/src/hooks/usePlayback.ts | 116 +++ training/smart-turn-zh/viewer/src/lib/asr.ts | 290 +++++++ .../viewer/src/{ => lib}/audio.ts | 5 +- .../viewer/src/{ => lib}/timeline.ts | 14 +- .../smart-turn-zh/viewer/src/{ => lib}/vad.ts | 7 +- .../viewer/src/{ => lib}/waveform.ts | 14 +- training/smart-turn-zh/viewer/src/main.ts | 439 ----------- training/smart-turn-zh/viewer/src/main.tsx | 5 + training/smart-turn-zh/viewer/tsconfig.json | 1 + training/smart-turn-zh/viewer/vite.config.ts | 2 + 21 files changed, 2112 insertions(+), 948 deletions(-) create mode 100644 training/smart-turn-zh/viewer/src/App.tsx delete mode 100644 training/smart-turn-zh/viewer/src/asr.ts create mode 100644 training/smart-turn-zh/viewer/src/components/ASRPanel.tsx create mode 100644 training/smart-turn-zh/viewer/src/components/Minimap.tsx create mode 100644 training/smart-turn-zh/viewer/src/components/Toolbar.tsx create mode 100644 training/smart-turn-zh/viewer/src/components/VADTrack.tsx create mode 100644 training/smart-turn-zh/viewer/src/components/WaveformTrack.tsx create mode 100644 training/smart-turn-zh/viewer/src/hooks/useCanvasInteraction.ts create mode 100644 training/smart-turn-zh/viewer/src/hooks/usePlayback.ts create mode 100644 training/smart-turn-zh/viewer/src/lib/asr.ts rename training/smart-turn-zh/viewer/src/{ => lib}/audio.ts (96%) rename training/smart-turn-zh/viewer/src/{ => lib}/timeline.ts (84%) rename training/smart-turn-zh/viewer/src/{ => lib}/vad.ts (95%) rename training/smart-turn-zh/viewer/src/{ => lib}/waveform.ts (90%) delete mode 100644 training/smart-turn-zh/viewer/src/main.ts create mode 100644 training/smart-turn-zh/viewer/src/main.tsx diff --git a/training/smart-turn-zh/viewer/index.html b/training/smart-turn-zh/viewer/index.html index 1aa333a..edc1e62 100644 --- a/training/smart-turn-zh/viewer/index.html +++ b/training/smart-turn-zh/viewer/index.html @@ -6,63 +6,7 @@ Audio Viewer -
-
-
- - - - -
-
- - - - - - -
-
- - - - --:-- / --:-- -
-
- -
-
- Waveform -
- - -
- -
-
- VAD - -
- - -
-
-
- - - -
- -
-
-
- - - +
+ diff --git a/training/smart-turn-zh/viewer/package-lock.json b/training/smart-turn-zh/viewer/package-lock.json index a8ce64d..18cfa88 100644 --- a/training/smart-turn-zh/viewer/package-lock.json +++ b/training/smart-turn-zh/viewer/package-lock.json @@ -1,17 +1,306 @@ { "name": "audio-viewer", - "version": "0.1.0", + "version": "0.2.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "audio-viewer", - "version": "0.1.0", + "version": "0.2.0", + "dependencies": { + "react": "^19.0.0", + "react-dom": "^19.0.0" + }, "devDependencies": { + "@types/react": "^19.0.0", + "@types/react-dom": "^19.0.0", + "@vitejs/plugin-react": "^4.3.0", "typescript": "^5.7.0", "vite": "^6.0.0" } }, + "node_modules/@babel/code-frame": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", + "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.28.5", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz", + "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", + "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-module-transforms": "^7.28.6", + "@babel/helpers": "^7.28.6", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/traverse": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/generator": { + "version": "7.29.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", + "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz", + "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.28.6", + "@babel/helper-validator-option": "^7.27.1", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz", + "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz", + "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.28.6", + "@babel/helper-validator-identifier": "^7.28.5", + "@babel/traverse": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz", + "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", + "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz", + "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz", + "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.0" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz", + "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-source": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz", + "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz", + "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.28.6", + "@babel/parser": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", + "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/@esbuild/aix-ppc64": { "version": "0.25.12", "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz", @@ -454,6 +743,63 @@ "node": ">=18" } }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.0-beta.27", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz", + "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==", + "dev": true, + "license": "MIT" + }, "node_modules/@rollup/rollup-android-arm-eabi": { "version": "4.60.2", "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.2.tgz", @@ -804,6 +1150,51 @@ "win32" ] }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.27.0", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz", + "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz", + "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.2" + } + }, "node_modules/@types/estree": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", @@ -811,6 +1202,154 @@ "dev": true, "license": "MIT" }, + "node_modules/@types/react": { + "version": "19.2.14", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz", + "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==", + "dev": true, + "license": "MIT", + "dependencies": { + "csstype": "^3.2.2" + } + }, + "node_modules/@types/react-dom": { + "version": "19.2.3", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz", + "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^19.2.0" + } + }, + "node_modules/@vitejs/plugin-react": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz", + "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.28.0", + "@babel/plugin-transform-react-jsx-self": "^7.27.1", + "@babel/plugin-transform-react-jsx-source": "^7.27.1", + "@rolldown/pluginutils": "1.0.0-beta.27", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.17.0" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/baseline-browser-mapping": { + "version": "2.10.20", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.20.tgz", + "integrity": "sha512-1AaXxEPfXT+GvTBJFuy4yXVHWJBXa4OdbIebGN/wX5DlsIkU0+wzGnd2lOzokSk51d5LUmqjgBLRLlypLUqInQ==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/browserslist": { + "version": "4.28.2", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz", + "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.10.12", + "caniuse-lite": "^1.0.30001782", + "electron-to-chromium": "^1.5.328", + "node-releases": "^2.0.36", + "update-browserslist-db": "^1.2.3" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001788", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001788.tgz", + "integrity": "sha512-6q8HFp+lOQtcf7wBK+uEenxymVWkGKkjFpCvw5W25cmMwEDU45p1xQFBQv8JDlMMry7eNxyBaR+qxgmTUZkIRQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/electron-to-chromium": { + "version": "1.5.340", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.340.tgz", + "integrity": "sha512-908qahOGocRMinT2nM3ajCEM99H4iPdv84eagPP3FfZy/1ZGeOy2CZYzjhms81ckOPCXPlW7LkY4XpxD8r1DrA==", + "dev": true, + "license": "ISC" + }, "node_modules/esbuild": { "version": "0.25.12", "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz", @@ -853,6 +1392,16 @@ "@esbuild/win32-x64": "0.25.12" } }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, "node_modules/fdir": { "version": "6.5.0", "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", @@ -886,6 +1435,66 @@ "node": "^8.16.0 || ^10.6.0 || >=11.0.0" } }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, "node_modules/nanoid": { "version": "3.3.11", "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", @@ -905,6 +1514,13 @@ "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" } }, + "node_modules/node-releases": { + "version": "2.0.37", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.37.tgz", + "integrity": "sha512-1h5gKZCF+pO/o3Iqt5Jp7wc9rH3eJJ0+nh/CIoiRwjRxde/hAHyLPXYN4V3CqKAbiZPSeJFSWHmJsbkicta0Eg==", + "dev": true, + "license": "MIT" + }, "node_modules/picocolors": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", @@ -954,6 +1570,37 @@ "node": "^10 || ^12 || >=14" } }, + "node_modules/react": { + "version": "19.2.5", + "resolved": "https://registry.npmjs.org/react/-/react-19.2.5.tgz", + "integrity": "sha512-llUJLzz1zTUBrskt2pwZgLq59AemifIftw4aB7JxOqf1HY2FDaGDxgwpAPVzHU1kdWabH7FauP4i1oEeer2WCA==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.2.5", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.5.tgz", + "integrity": "sha512-J5bAZz+DXMMwW/wV3xzKke59Af6CHY7G4uYLN1OvBcKEsWOs4pQExj86BBKamxl/Ik5bx9whOrvBlSDfWzgSag==", + "license": "MIT", + "dependencies": { + "scheduler": "^0.27.0" + }, + "peerDependencies": { + "react": "^19.2.5" + } + }, + "node_modules/react-refresh": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz", + "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/rollup": { "version": "4.60.2", "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.2.tgz", @@ -999,6 +1646,22 @@ "fsevents": "~2.3.2" } }, + "node_modules/scheduler": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz", + "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==", + "license": "MIT" + }, + "node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, "node_modules/source-map-js": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", @@ -1040,6 +1703,37 @@ "node": ">=14.17" } }, + "node_modules/update-browserslist-db": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, "node_modules/vite": { "version": "6.4.2", "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.2.tgz", @@ -1114,6 +1808,13 @@ "optional": true } } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" } } } diff --git a/training/smart-turn-zh/viewer/package.json b/training/smart-turn-zh/viewer/package.json index 6c6fe6e..abca164 100644 --- a/training/smart-turn-zh/viewer/package.json +++ b/training/smart-turn-zh/viewer/package.json @@ -1,14 +1,21 @@ { "name": "audio-viewer", "private": true, - "version": "0.1.0", + "version": "0.2.0", "type": "module", "scripts": { "dev": "vite", "build": "tsc && vite build", "preview": "vite preview" }, + "dependencies": { + "react": "^19.0.0", + "react-dom": "^19.0.0" + }, "devDependencies": { + "@types/react": "^19.0.0", + "@types/react-dom": "^19.0.0", + "@vitejs/plugin-react": "^4.3.0", "typescript": "^5.7.0", "vite": "^6.0.0" } diff --git a/training/smart-turn-zh/viewer/src/App.tsx b/training/smart-turn-zh/viewer/src/App.tsx new file mode 100644 index 0000000..b73b643 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/App.tsx @@ -0,0 +1,310 @@ +import { useRef, useState, useCallback, useEffect } from 'react'; +import { Timeline } from './lib/timeline'; +import { AudioStore } from './lib/audio'; +import type { WaveformScale } from './lib/waveform'; +import { + type Sentence, + parseSentences, searchSentences, zoomToSentence, +} from './lib/asr'; +import { Toolbar } from './components/Toolbar'; +import { WaveformTrack } from './components/WaveformTrack'; +import { VADTrack } from './components/VADTrack'; +import { Minimap } from './components/Minimap'; +import { ASRPanel } from './components/ASRPanel'; +import { usePlayback } from './hooks/usePlayback'; + +export function App() { + // Stable singleton instances + const [tl] = useState(() => new Timeline()); + const [audio] = useState(() => new AudioStore()); + + // File loading status + const [wavStatus, setWavStatus] = useState(''); + const [vadStatus, setVadStatus] = useState(''); + const [asrStatus, setAsrStatus] = useState(''); + + // Audio state + const [channelCount, setChannelCount] = useState(0); + const [channel, setChannel] = useState(-1); + const [scale, setScale] = useState('dB'); + const [gainValue, setGainValue] = useState(10.0); + + // VAD state + const [vadBuffer, setVadBuffer] = useState(null); + const [vadEntry, setVadEntry] = useState(0.3); + const [vadExit, setVadExit] = useState(0.1); + + // ASR state + const [sentences, setSentences] = useState([]); + const [searchQuery, setSearchQuery] = useState(''); + const [searchResults, setSearchResults] = useState([]); + const [searchIdx, setSearchIdx] = useState(-1); + + // Drop overlay + const [showDrop, setShowDrop] = useState(false); + + // Playback + const { playing, play, stop, setGain, invalidateBuffer } = usePlayback(tl, audio); + + // Refs for stable callbacks that need current values + const playingRef = useRef(playing); + const channelRef = useRef(channel); + const playRef = useRef(play); + const stopRef = useRef(stop); + playingRef.current = playing; + channelRef.current = channel; + playRef.current = play; + stopRef.current = stop; + + // Sentences ref for search callbacks + const sentencesRef = useRef(sentences); + sentencesRef.current = sentences; + + // Search state refs for next/prev + const searchResultsRef = useRef(searchResults); + const searchIdxRef = useRef(searchIdx); + searchResultsRef.current = searchResults; + searchIdxRef.current = searchIdx; + + // ---- Handlers ---- + + const handleSeek = useCallback((t: number) => { + tl.setCursor(t); + if (playingRef.current) { + stopRef.current(); + playRef.current(t, channelRef.current); + } + }, [tl]); + + const handlePlayToggle = useCallback(() => { + if (playingRef.current) { + stopRef.current(); + } else { + playRef.current(tl.cursor, channelRef.current); + } + }, [tl]); + + const handleChannelChange = useCallback((ch: number) => { + setChannel(ch); + invalidateBuffer(); + }, [invalidateBuffer]); + + const handleGainChange = useCallback((v: number) => { + setGainValue(v); + setGain(v); + }, [setGain]); + + // ---- File loading ---- + + const loadWav = useCallback(async (f: File) => { + setWavStatus('...'); + try { + await audio.load(f); + tl.sampleRate = audio.sampleRate; + tl.setDuration(audio.duration); + setChannelCount(audio.channelCount); + setChannel(-1); + invalidateBuffer(); + setWavStatus('\u2713'); + } catch (e) { + setWavStatus('\u2717'); + console.error(e); + } + }, [audio, tl, invalidateBuffer]); + + const loadVad = useCallback(async (f: File) => { + setVadStatus('...'); + try { + setVadBuffer(await f.arrayBuffer()); + setVadStatus('\u2713'); + } catch (e) { + setVadStatus('\u2717'); + console.error(e); + } + }, []); + + const loadAsr = useCallback(async (f: File) => { + setAsrStatus('...'); + try { + const json = JSON.parse(await f.text()); + const sents = parseSentences(Array.isArray(json) ? json : [json]); + setSentences(sents); + setSearchQuery(''); + setSearchResults([]); + setSearchIdx(-1); + setAsrStatus('\u2713'); + } catch (e) { + setAsrStatus('\u2717'); + console.error(e); + } + }, []); + + const routeFile = useCallback((f: File) => { + if (f.name.endsWith('.wav')) loadWav(f); + else if (f.name.endsWith('.npy')) loadVad(f); + else if (f.name.endsWith('.json')) loadAsr(f); + }, [loadWav, loadVad, loadAsr]); + + const handleFilesSelected = useCallback((files: File[]) => { + for (const f of files) routeFile(f); + }, [routeFile]); + + // ---- Search ---- + + const handleSearch = useCallback((q: string) => { + setSearchQuery(q); + const sents = sentencesRef.current; + const results = searchSentences(sents, q); + setSearchResults(results); + if (results.length) { + setSearchIdx(0); + zoomToSentence(tl, sents, results[0]); + } else { + setSearchIdx(-1); + } + }, [tl]); + + const handleSearchNext = useCallback(() => { + const results = searchResultsRef.current; + if (!results.length) return; + const next = (searchIdxRef.current + 1) % results.length; + setSearchIdx(next); + zoomToSentence(tl, sentencesRef.current, results[next]); + }, [tl]); + + const handleSearchPrev = useCallback(() => { + const results = searchResultsRef.current; + if (!results.length) return; + const prev = (searchIdxRef.current - 1 + results.length) % results.length; + setSearchIdx(prev); + zoomToSentence(tl, sentencesRef.current, results[prev]); + }, [tl]); + + // ---- Drag & Drop ---- + + useEffect(() => { + const onDragOver = (e: DragEvent) => { e.preventDefault(); setShowDrop(true); }; + const onDrop = (e: DragEvent) => { + e.preventDefault(); + setShowDrop(false); + for (const f of e.dataTransfer?.files ?? []) routeFile(f); + }; + document.addEventListener('dragover', onDragOver); + document.addEventListener('drop', onDrop); + return () => { + document.removeEventListener('dragover', onDragOver); + document.removeEventListener('drop', onDrop); + }; + }, [routeFile]); + + // ---- Keyboard shortcuts ---- + + useEffect(() => { + const onKeyDown = (e: KeyboardEvent) => { + const searchInput = document.getElementById('search-input'); + + // Let search input handle its own keys (except Escape) + if (e.target === searchInput && e.key !== 'Escape') return; + + switch (e.key) { + case ' ': + e.preventDefault(); + handlePlayToggle(); + break; + case 'f': + e.preventDefault(); + searchInput?.focus(); + break; + case 'Escape': + (document.activeElement as HTMLElement)?.blur(); + break; + case '=': case '+': + tl.zoom(0.67, 0.5); + break; + case '-': + tl.zoom(1.5, 0.5); + break; + case 'ArrowLeft': + tl.pan(-(tl.viewEnd - tl.viewStart) * 0.1); + break; + case 'ArrowRight': + tl.pan((tl.viewEnd - tl.viewStart) * 0.1); + break; + case '0': + handleChannelChange(-1); + break; + default: + if (e.key >= '1' && e.key <= '9') { + const ch = +e.key - 1; + if (ch < audio.channelCount) handleChannelChange(ch); + } + } + }; + document.addEventListener('keydown', onKeyDown); + return () => document.removeEventListener('keydown', onKeyDown); + }, [tl, audio, handlePlayToggle, handleChannelChange]); + + // ---- Render ---- + + return ( +
+ 0} + onPlayToggle={handlePlayToggle} + gainValue={gainValue} + onGainChange={handleGainChange} + /> + +
+ + +
+ + + + + + +
+ ); +} diff --git a/training/smart-turn-zh/viewer/src/asr.ts b/training/smart-turn-zh/viewer/src/asr.ts deleted file mode 100644 index 244bb7f..0000000 --- a/training/smart-turn-zh/viewer/src/asr.ts +++ /dev/null @@ -1,423 +0,0 @@ -import type { Timeline } from './timeline'; - -export interface CharTiming { - char: string; - start: number; // ms, -1 for punctuation without timestamp - end: number; -} - -export interface Sentence { - text: string; - start: number; // ms - end: number; // ms - chars: CharTiming[]; -} - -interface RawSentence { - text: string; start: number; end: number; - raw_text?: string; timestamp?: number[][]; -} - -export class ASRPanel { - sentences: Sentence[] = []; - results: number[] = []; - resultIdx = -1; - - private query = ''; - private listEl: HTMLElement; - private countEl: HTMLElement; - private activeCharEl: HTMLElement | null = null; - private activeCharRange: [number, number] = [-1, -1]; - - constructor( - container: HTMLElement, - private tl: Timeline, - ) { - this.listEl = container.querySelector('#transcript-list')!; - this.countEl = container.querySelector('#search-count')!; - } - - load(json: unknown[]) { - this.sentences = []; - for (const rec of json as Array<{ sentences?: RawSentence[] }>) { - if (rec.sentences) { - for (const s of rec.sentences) { - const chars = buildChars(s.text ?? '', s.raw_text ?? '', s.timestamp ?? []); - this.sentences.push({ text: s.text ?? '', start: s.start, end: s.end, chars }); - } - } - } - this.renderList(); - } - - search(q: string) { - this.query = q; - this.results = []; - this.resultIdx = -1; - if (q) { - const lower = q.toLowerCase(); - for (let i = 0; i < this.sentences.length; i++) { - if (this.sentences[i].text.toLowerCase().includes(lower)) { - this.results.push(i); - } - } - } - this.updateCount(); - this.renderList(); - if (this.results.length) this.goTo(0); - } - - next() { - if (!this.results.length) return; - this.goTo((this.resultIdx + 1) % this.results.length); - } - - prev() { - if (!this.results.length) return; - this.goTo((this.resultIdx - 1 + this.results.length) % this.results.length); - } - - /** Highlight the character at the given cursor time (karaoke). */ - highlightAt(timeMs: number) { - if (this.activeCharEl && timeMs >= this.activeCharRange[0] && timeMs < this.activeCharRange[1]) { - return; // still within current character - } - this.clearHighlight(); - - const si = this.findSentenceAt(timeMs); - if (si < 0) return; - - const s = this.sentences[si]; - let charIdx = -1; - for (let ci = 0; ci < s.chars.length; ci++) { - const c = s.chars[ci]; - if (c.start >= 0 && timeMs >= c.start && timeMs < c.end) { charIdx = ci; break; } - } - if (charIdx < 0) return; - - const sentEl = this.listEl.querySelector(`[data-idx="${si}"]`); - if (!sentEl) return; - const txtEl = sentEl.querySelector('.txt'); - if (!txtEl) return; - const el = txtEl.children[charIdx] as HTMLElement | undefined; - if (!el) return; - - el.classList.add('char-active'); - this.activeCharEl = el; - this.activeCharRange = [s.chars[charIdx].start, s.chars[charIdx].end]; - sentEl.scrollIntoView?.({ block: 'nearest', behavior: 'auto' }); - } - - clearHighlight() { - if (this.activeCharEl) { - this.activeCharEl.classList.remove('char-active'); - this.activeCharEl = null; - this.activeCharRange = [-1, -1]; - } - } - - /** Draw search-match highlights on a canvas. Call after waveform render. */ - drawOverlay(ctx: CanvasRenderingContext2D, w: number, h: number) { - if (!this.results.length) return; - const cur = this.resultIdx >= 0 ? this.results[this.resultIdx] : -1; - for (const idx of this.results) { - const s = this.sentences[idx]; - const x1 = this.tl.timeToX(s.start / 1000, w); - const x2 = this.tl.timeToX(s.end / 1000, w); - const left = Math.max(0, x1), right = Math.min(w, x2); - if (right <= left) continue; - ctx.fillStyle = idx === cur ? 'rgba(255,152,0,0.3)' : 'rgba(255,235,59,0.15)'; - ctx.fillRect(left, 0, right - left, h); - } - } - - /** Draw ASR segment boundaries and text labels on the canvas. */ - drawLabels(ctx: CanvasRenderingContext2D, w: number, h: number) { - if (!this.sentences.length) return; - const vStart = this.tl.viewStart; - const vEnd = this.tl.viewEnd; - const vSpan = vEnd - vStart; - - const fontSize = 11; - ctx.font = `${fontSize}px monospace`; - ctx.textBaseline = 'top'; - const rowH = fontSize + 6; - const labelY = h - rowH; - - for (let si = 0; si < this.sentences.length; si++) { - const s = this.sentences[si]; - const startSec = s.start / 1000; - const endSec = s.end / 1000; - if (endSec < vStart || startSec > vEnd) continue; - - const rawX1 = ((startSec - vStart) / vSpan) * w; - const rawX2 = ((endSec - vStart) / vSpan) * w; - const x1 = Math.max(0, rawX1); - const x2 = Math.min(w, rawX2); - const regionW = x2 - x1; - - // --- Alternating sentence background (full height) --- - const sentColor = si % 2 === 0 - ? 'rgba(79, 195, 247, 0.06)' - : 'rgba(255, 183, 77, 0.06)'; - ctx.fillStyle = sentColor; - ctx.fillRect(x1, 0, regionW, labelY); - - // --- Per-character shading + gap highlighting when zoomed in --- - const perChar = s.chars.length > 0 && regionW / s.text.length > 10; - if (perChar) { - let ci = 0; - let prevEndMs = s.start; // track end of previous char to find gaps - for (const c of s.chars) { - if (c.start < 0) continue; - const cEndMs = c.end >= 0 ? c.end : c.start; - - // Gap before this character - if (c.start > prevEndMs) { - const gx1 = Math.max(0, ((prevEndMs / 1000 - vStart) / vSpan) * w); - const gx2 = Math.min(w, ((c.start / 1000 - vStart) / vSpan) * w); - if (gx2 > gx1) { - ctx.fillStyle = 'rgba(244, 67, 54, 0.12)'; - ctx.fillRect(gx1, 0, gx2 - gx1, labelY); - } - } - - // Character region - const cx1 = ((c.start / 1000 - vStart) / vSpan) * w; - const cx2 = ((cEndMs / 1000 - vStart) / vSpan) * w; - const cl = Math.max(0, cx1), cr = Math.min(w, cx2); - if (cr > cl) { - ctx.fillStyle = ci % 2 === 0 - ? 'rgba(79, 195, 247, 0.08)' - : 'rgba(255, 183, 77, 0.08)'; - ctx.fillRect(cl, 0, cr - cl, labelY); - } - prevEndMs = cEndMs; - ci++; - } - // Gap after last character to sentence end - if (prevEndMs < s.end) { - const gx1 = Math.max(0, ((prevEndMs / 1000 - vStart) / vSpan) * w); - const gx2 = Math.min(w, ((endSec - vStart) / vSpan) * w); - if (gx2 > gx1) { - ctx.fillStyle = 'rgba(244, 67, 54, 0.12)'; - ctx.fillRect(gx1, 0, gx2 - gx1, labelY); - } - } - } - - // --- Sentence boundary lines (full height) --- - ctx.setLineDash([3, 3]); - ctx.lineWidth = 1; - ctx.strokeStyle = 'rgba(255, 235, 59, 0.4)'; - if (rawX1 >= 0 && rawX1 <= w) { - ctx.beginPath(); - ctx.moveTo(rawX1, 0); - ctx.lineTo(rawX1, h); - ctx.stroke(); - } - if (rawX2 >= 0 && rawX2 <= w) { - ctx.beginPath(); - ctx.moveTo(rawX2, 0); - ctx.lineTo(rawX2, h); - ctx.stroke(); - } - ctx.setLineDash([]); - - // --- Per-character boundary lines when zoomed in --- - if (perChar) { - ctx.strokeStyle = 'rgba(255, 255, 255, 0.12)'; - ctx.lineWidth = 0.5; - for (const c of s.chars) { - if (c.start < 0) continue; - const cx = ((c.start / 1000 - vStart) / vSpan) * w; - if (cx > x1 + 1 && cx <= x2) { - ctx.beginPath(); - ctx.moveTo(cx, 0); - ctx.lineTo(cx, h); - ctx.stroke(); - } - } - } - - if (regionW < 4) continue; - - // --- Text label bar at bottom --- - if (perChar) { - // Alternating background per character + gap highlights - let ci = 0; - let prevEnd = s.start; - for (const c of s.chars) { - if (c.start < 0) continue; - const cEnd = c.end >= 0 ? c.end : c.start; - // Gap in label bar - if (c.start > prevEnd) { - const gx1 = Math.max(x1, ((prevEnd / 1000 - vStart) / vSpan) * w); - const gx2 = Math.min(x2, ((c.start / 1000 - vStart) / vSpan) * w); - if (gx2 > gx1) { - ctx.fillStyle = 'rgba(244, 67, 54, 0.35)'; - ctx.fillRect(gx1, labelY, gx2 - gx1, rowH); - } - } - // Character cell - const cx1c = Math.max(x1, ((c.start / 1000 - vStart) / vSpan) * w); - const cx2c = Math.min(x2, ((cEnd / 1000 - vStart) / vSpan) * w); - if (cx2c > cx1c) { - ctx.fillStyle = ci % 2 === 0 - ? 'rgba(30, 60, 80, 0.85)' - : 'rgba(50, 40, 30, 0.85)'; - ctx.fillRect(cx1c, labelY, cx2c - cx1c, rowH); - } - prevEnd = cEnd; - ci++; - } - // Trailing gap - if (prevEnd < s.end) { - const gx1 = Math.max(x1, ((prevEnd / 1000 - vStart) / vSpan) * w); - const gx2 = Math.min(x2, ((endSec - vStart) / vSpan) * w); - if (gx2 > gx1) { - ctx.fillStyle = 'rgba(244, 67, 54, 0.35)'; - ctx.fillRect(gx1, labelY, gx2 - gx1, rowH); - } - } - } else { - ctx.fillStyle = 'rgba(0, 0, 0, 0.45)'; - ctx.fillRect(x1, labelY, regionW, rowH); - } - - // Clip text to region - ctx.save(); - ctx.beginPath(); - ctx.rect(x1 + 1, labelY, regionW - 2, rowH); - ctx.clip(); - - ctx.fillStyle = '#ddd'; - if (perChar) { - let lastEnd = s.start; - for (const c of s.chars) { - const cStart = c.start >= 0 ? c.start : lastEnd; - const cx = ((cStart / 1000 - vStart) / vSpan) * w; - ctx.fillText(c.char, cx + 1, labelY + 3); - if (c.end >= 0) lastEnd = c.end; - } - } else { - ctx.fillText(s.text, x1 + 2, labelY + 3); - } - - ctx.restore(); - } - } - - /** Zoom viewport to fit a sentence with some padding. */ - zoomToSentence(sentIdx: number) { - const s = this.sentences[sentIdx]; - if (!s) return; - const startSec = s.start / 1000; - const endSec = s.end / 1000; - const dur = endSec - startSec; - const pad = dur * 0.15; // 15% padding on each side - this.tl.setView(startSec - pad, endSec + pad); - this.tl.setCursor(startSec); - } - - private goTo(idx: number) { - this.resultIdx = idx; - const sentIdx = this.results[idx]; - this.zoomToSentence(sentIdx); - this.updateCount(); - this.renderList(); - const el = this.listEl.querySelector(`[data-idx="${sentIdx}"]`); - el?.scrollIntoView({ block: 'center', behavior: 'smooth' }); - } - - private updateCount() { - if (!this.query) { this.countEl.textContent = ''; return; } - this.countEl.textContent = this.results.length - ? `${this.resultIdx + 1}/${this.results.length}` - : 'No results'; - } - - renderList() { - this.clearHighlight(); - const matchSet = new Set(this.results); - const curSent = this.resultIdx >= 0 ? this.results[this.resultIdx] : -1; - let html = ''; - - for (let i = 0; i < this.sentences.length; i++) { - const s = this.sentences[i]; - const cls = i === curSent ? 'sentence current' - : matchSet.has(i) ? 'sentence match' : 'sentence'; - const time = fmtTime(s.start / 1000); - - const hlSet = this.query && matchSet.has(i) - ? matchHlSet(s.text, this.query) : null; - - let txtHtml = ''; - for (let ci = 0; ci < s.chars.length; ci++) { - const c = s.chars[ci]; - const hl = hlSet?.has(ci) ? ' search-hl' : ''; - const ch = escHtml(c.char); - if (c.start >= 0) { - txtHtml += `${ch}`; - } else { - txtHtml += `${ch}`; - } - } - - html += `
` + - `${time}${txtHtml}
`; - } - this.listEl.innerHTML = html; - } - - private findSentenceAt(timeMs: number): number { - for (let i = 0; i < this.sentences.length; i++) { - if (timeMs >= this.sentences[i].start && timeMs <= this.sentences[i].end) return i; - } - return -1; - } -} - -function buildChars(text: string, rawText: string, timestamps: number[][]): CharTiming[] { - const chars: CharTiming[] = []; - let ri = 0; - for (let i = 0; i < text.length; i++) { - if (ri < rawText.length && text[i] === rawText[ri]) { - const ts = timestamps[ri]; - chars.push({ char: text[i], start: ts?.[0] ?? -1, end: ts?.[1] ?? -1 }); - ri++; - } else { - chars.push({ char: text[i], start: -1, end: -1 }); - } - } - return chars; -} - -function matchHlSet(text: string, query: string): Set { - const set = new Set(); - const lower = text.toLowerCase(); - const q = query.toLowerCase(); - let pos = 0; - for (;;) { - const idx = lower.indexOf(q, pos); - if (idx === -1) break; - for (let i = idx; i < idx + q.length; i++) set.add(i); - pos = idx + 1; - } - return set; -} - -function fmtTime(sec: number): string { - const m = Math.floor(sec / 60); - const s = sec % 60; - return `${String(m).padStart(2, '0')}:${s.toFixed(1).padStart(4, '0')}`; -} - -function fmtMs(ms: number): string { - const sec = ms / 1000; - const m = Math.floor(sec / 60); - const s = sec % 60; - return `${String(m).padStart(2, '0')}:${s.toFixed(2).padStart(5, '0')}`; -} - -function escHtml(s: string) { return s.replace(/&/g, '&').replace(//g, '>'); } diff --git a/training/smart-turn-zh/viewer/src/components/ASRPanel.tsx b/training/smart-turn-zh/viewer/src/components/ASRPanel.tsx new file mode 100644 index 0000000..72fdae5 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/components/ASRPanel.tsx @@ -0,0 +1,184 @@ +import { useRef, useEffect, useCallback, memo } from 'react'; +import type { Timeline } from '../lib/timeline'; +import { + type Sentence, + matchHlSet, fmtTime, fmtMs, zoomToSentence, +} from '../lib/asr'; + +interface ASRPanelProps { + timeline: Timeline; + sentences: Sentence[]; + searchQuery: string; + searchResults: number[]; + searchResultIdx: number; + onSearchChange: (q: string) => void; + onNext: () => void; + onPrev: () => void; + onSeek: (time: number) => void; + playing: boolean; +} + +export const ASRPanel = memo(function ASRPanel({ + timeline, sentences, searchQuery, searchResults, searchResultIdx, + onSearchChange, onNext, onPrev, onSeek, playing, +}: ASRPanelProps) { + const listRef = useRef(null); + const activeCharRef = useRef(null); + const activeRangeRef = useRef<[number, number]>([-1, -1]); + + // Keep sentences in ref for stable callbacks + const sentencesRef = useRef(sentences); + sentencesRef.current = sentences; + + const clearHighlight = useCallback(() => { + if (activeCharRef.current) { + activeCharRef.current.classList.remove('char-active'); + activeCharRef.current = null; + activeRangeRef.current = [-1, -1]; + } + }, []); + + const highlightAt = useCallback((timeMs: number) => { + // Skip if still within current character + if ( + activeCharRef.current && + timeMs >= activeRangeRef.current[0] && + timeMs < activeRangeRef.current[1] + ) { + return; + } + clearHighlight(); + + const sents = sentencesRef.current; + let si = -1; + for (let i = 0; i < sents.length; i++) { + if (timeMs >= sents[i].start && timeMs <= sents[i].end) { si = i; break; } + } + if (si < 0) return; + + const s = sents[si]; + let charIdx = -1; + for (let ci = 0; ci < s.chars.length; ci++) { + const c = s.chars[ci]; + if (c.start >= 0 && timeMs >= c.start && timeMs < c.end) { charIdx = ci; break; } + } + if (charIdx < 0) return; + + const sentEl = listRef.current?.querySelector(`[data-idx="${si}"]`); + if (!sentEl) return; + const txtEl = sentEl.querySelector('.txt'); + if (!txtEl) return; + const el = txtEl.children[charIdx] as HTMLElement | undefined; + if (!el) return; + + el.classList.add('char-active'); + activeCharRef.current = el; + activeRangeRef.current = [s.chars[charIdx].start, s.chars[charIdx].end]; + sentEl.scrollIntoView?.({ block: 'nearest', behavior: 'auto' }); + }, [clearHighlight]); + + // Subscribe to timeline for karaoke highlighting + useEffect(() => { + return timeline.onUpdate(() => highlightAt(timeline.cursor * 1000)); + }, [timeline, highlightAt]); + + // Re-apply karaoke after DOM rebuild + useEffect(() => { + clearHighlight(); + highlightAt(timeline.cursor * 1000); + }, [sentences, searchQuery, searchResults, searchResultIdx, clearHighlight, highlightAt, timeline]); + + // Scroll current search result into view + const currentSent = searchResultIdx >= 0 ? searchResults[searchResultIdx] : -1; + useEffect(() => { + if (currentSent >= 0) { + const el = listRef.current?.querySelector(`[data-idx="${currentSent}"]`); + el?.scrollIntoView({ block: 'center', behavior: 'smooth' }); + } + }, [currentSent]); + + // Handle click on a sentence or character + const handleClick = useCallback((e: React.MouseEvent) => { + const el = (e.target as HTMLElement).closest('.sentence') as HTMLElement | null; + if (!el) return; + const sentIdx = +el.dataset.idx!; + + const charEl = (e.target as HTMLElement).closest('.char') as HTMLElement | null; + const t = charEl ? +charEl.dataset.cs! / 1000 : +el.dataset.start! / 1000; + + zoomToSentence(timeline, sentencesRef.current, sentIdx); + onSeek(t); + }, [timeline, onSeek]); + + const matchSet = new Set(searchResults); + const searchCount = searchQuery + ? (searchResults.length ? `${searchResultIdx + 1}/${searchResults.length}` : 'No results') + : ''; + + return ( +
+ +
+ {sentences.map((s, i) => { + const cls = i === currentSent + ? 'sentence current' + : matchSet.has(i) ? 'sentence match' : 'sentence'; + const hlSet = searchQuery && matchSet.has(i) + ? matchHlSet(s.text, searchQuery) : null; + + return ( +
+ {fmtTime(s.start / 1000)} + + {s.chars.map((c, ci) => { + const hl = hlSet?.has(ci) ? ' search-hl' : ''; + if (c.start >= 0) { + return ( + + {c.char} + + ); + } + return {c.char}; + })} + +
+ ); + })} +
+
+ ); +}); diff --git a/training/smart-turn-zh/viewer/src/components/Minimap.tsx b/training/smart-turn-zh/viewer/src/components/Minimap.tsx new file mode 100644 index 0000000..6195794 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/components/Minimap.tsx @@ -0,0 +1,78 @@ +import { useRef, useEffect, useCallback, memo } from 'react'; +import type { Timeline } from '../lib/timeline'; +import type { AudioStore } from '../lib/audio'; + +interface MinimapProps { + timeline: Timeline; + audio: AudioStore; + channel: number; +} + +export const Minimap = memo(function Minimap({ timeline, audio, channel }: MinimapProps) { + const canvasRef = useRef(null); + const channelRef = useRef(channel); + channelRef.current = channel; + + const draw = useCallback(() => { + const canvas = canvasRef.current; + if (!canvas || !audio.raw) return; + + const dpr = devicePixelRatio; + const rect = canvas.getBoundingClientRect(); + canvas.width = rect.width * dpr; + canvas.height = rect.height * dpr; + const ctx = canvas.getContext('2d')!; + const w = rect.width, h = rect.height; + ctx.setTransform(dpr, 0, 0, dpr, 0, 0); + ctx.clearRect(0, 0, w, h); + + // Coarsest LOD waveform overview + const ch = channelRef.current; + const levels = audio.getLOD(ch); + if (levels.length) { + const lv = levels[levels.length - 1]; + const mid = h / 2, amp = mid; + ctx.fillStyle = '#1e3a4a'; + ctx.beginPath(); + for (let x = 0; x < w; x++) { + const b = Math.min(Math.floor((x / w) * lv.max.length), lv.max.length - 1); + x === 0 ? ctx.moveTo(x, mid - lv.max[b] * amp) : ctx.lineTo(x, mid - lv.max[b] * amp); + } + for (let x = w - 1; x >= 0; x--) { + const b = Math.min(Math.floor((x / w) * lv.min.length), lv.min.length - 1); + ctx.lineTo(x, mid - lv.min[b] * amp); + } + ctx.closePath(); + ctx.fill(); + } + + // Viewport indicator + const x1 = (timeline.viewStart / timeline.duration) * w; + const x2 = (timeline.viewEnd / timeline.duration) * w; + ctx.fillStyle = 'rgba(79,195,247,0.15)'; + ctx.fillRect(x1, 0, x2 - x1, h); + ctx.strokeStyle = '#4fc3f7'; + ctx.lineWidth = 1; + ctx.strokeRect(x1 + 0.5, 0.5, x2 - x1 - 1, h - 1); + }, [timeline, audio]); + + // Subscribe to timeline updates + useEffect(() => { + return timeline.onUpdate(draw); + }, [timeline, draw]); + + // Redraw on channel change + useEffect(draw, [channel, draw]); + + const handleClick = useCallback((e: React.MouseEvent) => { + const canvas = canvasRef.current; + if (!canvas) return; + const rect = canvas.getBoundingClientRect(); + const frac = (e.clientX - rect.left) / rect.width; + const t = frac * timeline.duration; + const span = timeline.viewEnd - timeline.viewStart; + timeline.setView(t - span / 2, t + span / 2); + }, [timeline]); + + return ; +}); diff --git a/training/smart-turn-zh/viewer/src/components/Toolbar.tsx b/training/smart-turn-zh/viewer/src/components/Toolbar.tsx new file mode 100644 index 0000000..4569ead --- /dev/null +++ b/training/smart-turn-zh/viewer/src/components/Toolbar.tsx @@ -0,0 +1,124 @@ +import { useRef, useEffect, useCallback, useState, memo } from 'react'; +import type { Timeline } from '../lib/timeline'; +import { fmtTime } from '../lib/asr'; + +const ZOOM_PRESETS = [ + { label: '1s', span: 1 }, + { label: '20s', span: 20 }, + { label: '1m', span: 80 }, + { label: '5m', span: 300 }, + { label: '20m', span: 1200 }, + { label: 'Full', span: 0 }, +]; + +interface ToolbarProps { + timeline: Timeline; + onFilesSelected: (files: File[]) => void; + wavStatus: string; + vadStatus: string; + asrStatus: string; + channelCount: number; + channel: number; + onChannelChange: (ch: number) => void; + playing: boolean; + canPlay: boolean; + onPlayToggle: () => void; + gainValue: number; + onGainChange: (v: number) => void; +} + +export const Toolbar = memo(function Toolbar({ + timeline, onFilesSelected, + wavStatus, vadStatus, asrStatus, + channelCount, channel, onChannelChange, + playing, canPlay, onPlayToggle, + gainValue, onGainChange, +}: ToolbarProps) { + const timeRef = useRef(null); + const [activeZoom, setActiveZoom] = useState(null); + + // Update time display imperatively (60fps during playback) + useEffect(() => { + const update = () => { + if (timeRef.current) { + timeRef.current.textContent = `${fmtTime(timeline.cursor)} / ${fmtTime(timeline.duration)}`; + } + }; + update(); + return timeline.onUpdate(update); + }, [timeline]); + + const handleFileInput = useCallback((e: React.ChangeEvent) => { + const files = Array.from(e.target.files ?? []); + if (files.length) onFilesSelected(files); + }, [onFilesSelected]); + + const handleZoom = useCallback((span: number, idx: number) => { + if (span === 0) { + timeline.setView(0, timeline.duration); + } else { + const center = (timeline.viewStart + timeline.viewEnd) / 2; + timeline.setView(center - span / 2, center + span / 2); + } + setActiveZoom(idx); + }, [timeline]); + + return ( +
+
+ + {wavStatus} + {vadStatus} + {asrStatus} +
+
+ {ZOOM_PRESETS.map((z, i) => ( + + ))} +
+
+ +
+
+ ); +}); diff --git a/training/smart-turn-zh/viewer/src/components/VADTrack.tsx b/training/smart-turn-zh/viewer/src/components/VADTrack.tsx new file mode 100644 index 0000000..dc2b4f8 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/components/VADTrack.tsx @@ -0,0 +1,95 @@ +import { useRef, useEffect, useCallback, memo } from 'react'; +import type { Timeline } from '../lib/timeline'; +import { VADRenderer } from '../lib/vad'; +import { useCanvasInteraction } from '../hooks/useCanvasInteraction'; + +interface VADTrackProps { + timeline: Timeline; + vadBuffer: ArrayBuffer | null; + entryThreshold: number; + exitThreshold: number; + onEntryChange: (v: number) => void; + onExitChange: (v: number) => void; + onSeek: (t: number) => void; +} + +export const VADTrack = memo(function VADTrack({ + timeline, vadBuffer, entryThreshold, exitThreshold, + onEntryChange, onExitChange, onSeek, +}: VADTrackProps) { + const canvasRef = useRef(null); + const rendererRef = useRef(null); + + const entryRef = useRef(entryThreshold); + const exitRef = useRef(exitThreshold); + entryRef.current = entryThreshold; + exitRef.current = exitThreshold; + + const draw = useCallback(() => { + const r = rendererRef.current; + if (!r) return; + r.entryThreshold = entryRef.current; + r.exitThreshold = exitRef.current; + r.render(); + }, []); + + // Initialize renderer + useEffect(() => { + const canvas = canvasRef.current; + if (!canvas) return; + + const r = new VADRenderer(canvas, timeline); + rendererRef.current = r; + r.resize(); + + const unsub = timeline.onUpdate(draw); + const ro = new ResizeObserver(() => { r.resize(); draw(); }); + ro.observe(canvas.parentElement!); + + return () => { unsub(); ro.disconnect(); rendererRef.current = null; }; + }, [timeline, draw]); + + // Load VAD data when buffer changes + useEffect(() => { + if (vadBuffer && rendererRef.current) { + rendererRef.current.load(vadBuffer); + draw(); + } + }, [vadBuffer, draw]); + + // Redraw on threshold changes + useEffect(draw, [entryThreshold, exitThreshold, draw]); + + useCanvasInteraction(canvasRef, timeline, onSeek); + + return ( +
+ VAD + +
+ + +
+
+ ); +}); diff --git a/training/smart-turn-zh/viewer/src/components/WaveformTrack.tsx b/training/smart-turn-zh/viewer/src/components/WaveformTrack.tsx new file mode 100644 index 0000000..a90b6fc --- /dev/null +++ b/training/smart-turn-zh/viewer/src/components/WaveformTrack.tsx @@ -0,0 +1,111 @@ +import { useRef, useEffect, useCallback, memo } from 'react'; +import type { Timeline } from '../lib/timeline'; +import type { AudioStore } from '../lib/audio'; +import { WaveformRenderer, type WaveformScale } from '../lib/waveform'; +import { drawASROverlay, drawASRLabels, type Sentence } from '../lib/asr'; +import { useCanvasInteraction } from '../hooks/useCanvasInteraction'; + +interface WaveformTrackProps { + timeline: Timeline; + audio: AudioStore; + channel: number; + scale: WaveformScale; + onScaleChange: (s: WaveformScale) => void; + sentences: Sentence[]; + searchResults: number[]; + searchResultIdx: number; + onSeek: (t: number) => void; +} + +export const WaveformTrack = memo(function WaveformTrack({ + timeline, audio, channel, scale, onScaleChange, + sentences, searchResults, searchResultIdx, onSeek, +}: WaveformTrackProps) { + const canvasRef = useRef(null); + const wfRef = useRef(null); + + // Store frequently-changing data in refs for the stable draw callback + const channelRef = useRef(channel); + const scaleRef = useRef(scale); + const sentencesRef = useRef(sentences); + const resultsRef = useRef(searchResults); + const resultIdxRef = useRef(searchResultIdx); + channelRef.current = channel; + scaleRef.current = scale; + sentencesRef.current = sentences; + resultsRef.current = searchResults; + resultIdxRef.current = searchResultIdx; + + // Stable draw function — reads everything from refs + const draw = useCallback(() => { + const wf = wfRef.current; + const canvas = canvasRef.current; + if (!wf || !canvas) return; + + wf.channel = channelRef.current; + wf.scale = scaleRef.current; + wf.render(); + + // ASR overlays on top of waveform + const sents = sentencesRef.current; + if (sents.length) { + const dpr = devicePixelRatio; + const w = canvas.width / dpr; + const h = canvas.height / dpr; + const ctx = canvas.getContext('2d')!; + ctx.setTransform(dpr, 0, 0, dpr, 0, 0); + const results = resultsRef.current; + if (results.length) { + drawASROverlay(ctx, w, h, timeline, sents, results, resultIdxRef.current); + } + drawASRLabels(ctx, w, h, timeline, sents); + } + }, [timeline]); + + // Initialize renderer, subscribe to timeline, observe resize + useEffect(() => { + const canvas = canvasRef.current; + if (!canvas) return; + + const wf = new WaveformRenderer(canvas, timeline, audio); + wfRef.current = wf; + wf.resize(); + draw(); + + const unsub = timeline.onUpdate(draw); + const ro = new ResizeObserver(() => { wf.resize(); draw(); }); + ro.observe(canvas.parentElement!); + + return () => { + unsub(); + ro.disconnect(); + wfRef.current = null; + }; + }, [timeline, audio, draw]); + + // Redraw when display props change + useEffect(draw, [channel, scale, sentences, searchResults, searchResultIdx, draw]); + + useCanvasInteraction(canvasRef, timeline, onSeek); + + return ( +
+ Waveform +
+ + +
+ +
+ ); +}); diff --git a/training/smart-turn-zh/viewer/src/hooks/useCanvasInteraction.ts b/training/smart-turn-zh/viewer/src/hooks/useCanvasInteraction.ts new file mode 100644 index 0000000..55030b1 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/hooks/useCanvasInteraction.ts @@ -0,0 +1,68 @@ +import { useEffect, useRef, type RefObject } from 'react'; +import type { Timeline } from '../lib/timeline'; + +/** + * Adds wheel zoom, drag pan, and click-to-seek to a canvas element. + */ +export function useCanvasInteraction( + canvasRef: RefObject, + timeline: Timeline, + onSeek?: (time: number) => void, +) { + const onSeekRef = useRef(onSeek); + onSeekRef.current = onSeek; + + useEffect(() => { + const canvas = canvasRef.current; + if (!canvas) return; + + const onWheel = (e: WheelEvent) => { + e.preventDefault(); + if (e.metaKey || e.ctrlKey) { + const rect = canvas.getBoundingClientRect(); + const frac = (e.clientX - rect.left) / rect.width; + timeline.zoom(e.deltaY > 0 ? 1.25 : 0.8, frac); + } else { + const span = timeline.viewEnd - timeline.viewStart; + timeline.pan((e.deltaY > 0 ? 0.15 : -0.15) * span); + } + }; + + let drag = false, startX = 0, startVS = 0, moved = false; + + const onMouseDown = (e: MouseEvent) => { + drag = true; moved = false; startX = e.clientX; startVS = timeline.viewStart; + }; + const onMouseMove = (e: MouseEvent) => { + if (!drag) return; + const dx = e.clientX - startX; + if (Math.abs(dx) > 3) moved = true; + if (!moved) return; + const rect = canvas.getBoundingClientRect(); + const span = timeline.viewEnd - timeline.viewStart; + const dt = -(dx / rect.width) * span; + timeline.setView(startVS + dt, startVS + dt + span); + }; + const onMouseUp = (e: MouseEvent) => { + if (!drag) return; + drag = false; + if (!moved) { + const rect = canvas.getBoundingClientRect(); + const t = timeline.xToTime(e.clientX - rect.left, rect.width); + onSeekRef.current?.(t); + } + }; + + canvas.addEventListener('wheel', onWheel, { passive: false }); + canvas.addEventListener('mousedown', onMouseDown); + window.addEventListener('mousemove', onMouseMove); + window.addEventListener('mouseup', onMouseUp); + + return () => { + canvas.removeEventListener('wheel', onWheel); + canvas.removeEventListener('mousedown', onMouseDown); + window.removeEventListener('mousemove', onMouseMove); + window.removeEventListener('mouseup', onMouseUp); + }; + }, [canvasRef, timeline]); +} diff --git a/training/smart-turn-zh/viewer/src/hooks/usePlayback.ts b/training/smart-turn-zh/viewer/src/hooks/usePlayback.ts new file mode 100644 index 0000000..bdb4321 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/hooks/usePlayback.ts @@ -0,0 +1,116 @@ +import { useState, useCallback, useRef, useEffect } from 'react'; +import type { Timeline } from '../lib/timeline'; +import type { AudioStore } from '../lib/audio'; + +export function usePlayback(timeline: Timeline, audio: AudioStore) { + const [playing, setPlaying] = useState(false); + + const actxRef = useRef(null); + const srcRef = useRef(null); + const gainNodeRef = useRef(null); + const playBufRef = useRef(null); + const playChannelRef = useRef(-1); + const playT0Ref = useRef(0); + const playOffRef = useRef(0); + const gainValueRef = useRef(10.0); + const playingRef = useRef(false); + const rafIdRef = useRef(0); + + const stop = useCallback(() => { + playingRef.current = false; + cancelAnimationFrame(rafIdRef.current); + + if (srcRef.current) { + srcRef.current.onended = null; + try { srcRef.current.stop(); } catch { /* already stopped */ } + srcRef.current = null; + } + if (actxRef.current) { + const elapsed = actxRef.current.currentTime - playT0Ref.current; + timeline.cursor = Math.min(playOffRef.current + elapsed, timeline.duration); + actxRef.current.close(); + actxRef.current = null; + } + gainNodeRef.current = null; + setPlaying(false); + timeline.flush(); + }, [timeline]); + + const stopRef = useRef(stop); + stopRef.current = stop; + + const play = useCallback((offset: number, channel: number) => { + if (!audio.raw) return; + + // Stop any existing playback + if (playingRef.current) stopRef.current(); + + // Ensure buffer for channel + if (!playBufRef.current || playChannelRef.current !== channel) { + playBufRef.current = audio.createAudioBuffer(channel); + playChannelRef.current = channel; + } + const buf = playBufRef.current; + if (!buf) return; + + const actx = new AudioContext({ sampleRate: audio.sampleRate }); + const gainNode = actx.createGain(); + gainNode.gain.value = gainValueRef.current; + gainNode.connect(actx.destination); + const src = actx.createBufferSource(); + src.buffer = buf; + src.connect(gainNode); + src.start(0, offset); + src.onended = () => stopRef.current(); + + actxRef.current = actx; + srcRef.current = src; + gainNodeRef.current = gainNode; + playT0Ref.current = actx.currentTime; + playOffRef.current = offset; + playingRef.current = true; + setPlaying(true); + + const loop = () => { + if (!playingRef.current) return; + const a = actxRef.current; + if (!a) return; + const t = playOffRef.current + (a.currentTime - playT0Ref.current); + if (t >= timeline.duration) { stopRef.current(); return; } + timeline.cursor = t; + // Auto-scroll when cursor exits viewport + if (t > timeline.viewEnd) { + const span = timeline.viewEnd - timeline.viewStart; + timeline.viewStart = t; + timeline.viewEnd = t + span; + } + timeline.flush(); + rafIdRef.current = requestAnimationFrame(loop); + }; + rafIdRef.current = requestAnimationFrame(loop); + }, [audio, timeline]); + + const setGain = useCallback((value: number) => { + gainValueRef.current = value; + if (gainNodeRef.current) gainNodeRef.current.gain.value = value; + }, []); + + const invalidateBuffer = useCallback(() => { + playBufRef.current = null; + }, []); + + // Cleanup on unmount + useEffect(() => { + return () => { + playingRef.current = false; + cancelAnimationFrame(rafIdRef.current); + if (srcRef.current) { + srcRef.current.onended = null; + try { srcRef.current.stop(); } catch { /* already stopped */ } + } + actxRef.current?.close(); + }; + }, []); + + return { playing, play, stop, setGain, invalidateBuffer }; +} diff --git a/training/smart-turn-zh/viewer/src/lib/asr.ts b/training/smart-turn-zh/viewer/src/lib/asr.ts new file mode 100644 index 0000000..3f63d4d --- /dev/null +++ b/training/smart-turn-zh/viewer/src/lib/asr.ts @@ -0,0 +1,290 @@ +import type { Timeline } from './timeline'; + +export interface CharTiming { + char: string; + start: number; // ms, -1 for punctuation without timestamp + end: number; +} + +export interface Sentence { + text: string; + start: number; // ms + end: number; // ms + chars: CharTiming[]; +} + +interface RawSentence { + text: string; start: number; end: number; + raw_text?: string; timestamp?: number[][]; +} + +// ---- Data parsing ---- + +export function parseSentences(json: unknown[]): Sentence[] { + const sentences: Sentence[] = []; + for (const rec of json as Array<{ sentences?: RawSentence[] }>) { + if (rec.sentences) { + for (const s of rec.sentences) { + const chars = buildChars(s.text ?? '', s.raw_text ?? '', s.timestamp ?? []); + sentences.push({ text: s.text ?? '', start: s.start, end: s.end, chars }); + } + } + } + return sentences; +} + +export function searchSentences(sentences: Sentence[], query: string): number[] { + if (!query) return []; + const lower = query.toLowerCase(); + const results: number[] = []; + for (let i = 0; i < sentences.length; i++) { + if (sentences[i].text.toLowerCase().includes(lower)) results.push(i); + } + return results; +} + +export function zoomToSentence(tl: Timeline, sentences: Sentence[], sentIdx: number): void { + const s = sentences[sentIdx]; + if (!s) return; + const startSec = s.start / 1000; + const endSec = s.end / 1000; + const dur = endSec - startSec; + const pad = dur * 0.15; + tl.setView(startSec - pad, endSec + pad); + tl.setCursor(startSec); +} + +// ---- Canvas drawing ---- + +export function drawASROverlay( + ctx: CanvasRenderingContext2D, w: number, h: number, + tl: Timeline, sentences: Sentence[], + results: number[], currentResultIdx: number, +): void { + if (!results.length) return; + const cur = currentResultIdx >= 0 ? results[currentResultIdx] : -1; + for (const idx of results) { + const s = sentences[idx]; + const x1 = tl.timeToX(s.start / 1000, w); + const x2 = tl.timeToX(s.end / 1000, w); + const left = Math.max(0, x1), right = Math.min(w, x2); + if (right <= left) continue; + ctx.fillStyle = idx === cur ? 'rgba(255,152,0,0.3)' : 'rgba(255,235,59,0.15)'; + ctx.fillRect(left, 0, right - left, h); + } +} + +export function drawASRLabels( + ctx: CanvasRenderingContext2D, w: number, h: number, + tl: Timeline, sentences: Sentence[], +): void { + if (!sentences.length) return; + const vStart = tl.viewStart; + const vEnd = tl.viewEnd; + const vSpan = vEnd - vStart; + + const fontSize = 11; + ctx.font = `${fontSize}px monospace`; + ctx.textBaseline = 'top'; + const rowH = fontSize + 6; + const labelY = h - rowH; + + for (let si = 0; si < sentences.length; si++) { + const s = sentences[si]; + const startSec = s.start / 1000; + const endSec = s.end / 1000; + if (endSec < vStart || startSec > vEnd) continue; + + const rawX1 = ((startSec - vStart) / vSpan) * w; + const rawX2 = ((endSec - vStart) / vSpan) * w; + const x1 = Math.max(0, rawX1); + const x2 = Math.min(w, rawX2); + const regionW = x2 - x1; + + // Alternating sentence background + const sentColor = si % 2 === 0 + ? 'rgba(79, 195, 247, 0.06)' + : 'rgba(255, 183, 77, 0.06)'; + ctx.fillStyle = sentColor; + ctx.fillRect(x1, 0, regionW, labelY); + + // Per-character shading + gap highlighting when zoomed in + const perChar = s.chars.length > 0 && regionW / s.text.length > 10; + if (perChar) { + let ci = 0; + let prevEndMs = s.start; + for (const c of s.chars) { + if (c.start < 0) continue; + const cEndMs = c.end >= 0 ? c.end : c.start; + + if (c.start > prevEndMs) { + const gx1 = Math.max(0, ((prevEndMs / 1000 - vStart) / vSpan) * w); + const gx2 = Math.min(w, ((c.start / 1000 - vStart) / vSpan) * w); + if (gx2 > gx1) { + ctx.fillStyle = 'rgba(244, 67, 54, 0.12)'; + ctx.fillRect(gx1, 0, gx2 - gx1, labelY); + } + } + + const cx1 = ((c.start / 1000 - vStart) / vSpan) * w; + const cx2 = ((cEndMs / 1000 - vStart) / vSpan) * w; + const cl = Math.max(0, cx1), cr = Math.min(w, cx2); + if (cr > cl) { + ctx.fillStyle = ci % 2 === 0 + ? 'rgba(79, 195, 247, 0.08)' + : 'rgba(255, 183, 77, 0.08)'; + ctx.fillRect(cl, 0, cr - cl, labelY); + } + prevEndMs = cEndMs; + ci++; + } + if (prevEndMs < s.end) { + const gx1 = Math.max(0, ((prevEndMs / 1000 - vStart) / vSpan) * w); + const gx2 = Math.min(w, ((endSec - vStart) / vSpan) * w); + if (gx2 > gx1) { + ctx.fillStyle = 'rgba(244, 67, 54, 0.12)'; + ctx.fillRect(gx1, 0, gx2 - gx1, labelY); + } + } + } + + // Sentence boundary lines + ctx.setLineDash([3, 3]); + ctx.lineWidth = 1; + ctx.strokeStyle = 'rgba(255, 235, 59, 0.4)'; + if (rawX1 >= 0 && rawX1 <= w) { + ctx.beginPath(); + ctx.moveTo(rawX1, 0); + ctx.lineTo(rawX1, h); + ctx.stroke(); + } + if (rawX2 >= 0 && rawX2 <= w) { + ctx.beginPath(); + ctx.moveTo(rawX2, 0); + ctx.lineTo(rawX2, h); + ctx.stroke(); + } + ctx.setLineDash([]); + + // Per-character boundary lines + if (perChar) { + ctx.strokeStyle = 'rgba(255, 255, 255, 0.12)'; + ctx.lineWidth = 0.5; + for (const c of s.chars) { + if (c.start < 0) continue; + const cx = ((c.start / 1000 - vStart) / vSpan) * w; + if (cx > x1 + 1 && cx <= x2) { + ctx.beginPath(); + ctx.moveTo(cx, 0); + ctx.lineTo(cx, h); + ctx.stroke(); + } + } + } + + if (regionW < 4) continue; + + // Text label bar at bottom + if (perChar) { + let ci = 0; + let prevEnd = s.start; + for (const c of s.chars) { + if (c.start < 0) continue; + const cEnd = c.end >= 0 ? c.end : c.start; + if (c.start > prevEnd) { + const gx1 = Math.max(x1, ((prevEnd / 1000 - vStart) / vSpan) * w); + const gx2 = Math.min(x2, ((c.start / 1000 - vStart) / vSpan) * w); + if (gx2 > gx1) { + ctx.fillStyle = 'rgba(244, 67, 54, 0.35)'; + ctx.fillRect(gx1, labelY, gx2 - gx1, rowH); + } + } + const cx1c = Math.max(x1, ((c.start / 1000 - vStart) / vSpan) * w); + const cx2c = Math.min(x2, ((cEnd / 1000 - vStart) / vSpan) * w); + if (cx2c > cx1c) { + ctx.fillStyle = ci % 2 === 0 + ? 'rgba(30, 60, 80, 0.85)' + : 'rgba(50, 40, 30, 0.85)'; + ctx.fillRect(cx1c, labelY, cx2c - cx1c, rowH); + } + prevEnd = cEnd; + ci++; + } + if (prevEnd < s.end) { + const gx1 = Math.max(x1, ((prevEnd / 1000 - vStart) / vSpan) * w); + const gx2 = Math.min(x2, ((endSec - vStart) / vSpan) * w); + if (gx2 > gx1) { + ctx.fillStyle = 'rgba(244, 67, 54, 0.35)'; + ctx.fillRect(gx1, labelY, gx2 - gx1, rowH); + } + } + } else { + ctx.fillStyle = 'rgba(0, 0, 0, 0.45)'; + ctx.fillRect(x1, labelY, regionW, rowH); + } + + ctx.save(); + ctx.beginPath(); + ctx.rect(x1 + 1, labelY, regionW - 2, rowH); + ctx.clip(); + + ctx.fillStyle = '#ddd'; + if (perChar) { + let lastEnd = s.start; + for (const c of s.chars) { + const cStart = c.start >= 0 ? c.start : lastEnd; + const cx = ((cStart / 1000 - vStart) / vSpan) * w; + ctx.fillText(c.char, cx + 1, labelY + 3); + if (c.end >= 0) lastEnd = c.end; + } + } else { + ctx.fillText(s.text, x1 + 2, labelY + 3); + } + + ctx.restore(); + } +} + +// ---- Utilities ---- + +export function matchHlSet(text: string, query: string): Set { + const set = new Set(); + const lower = text.toLowerCase(); + const q = query.toLowerCase(); + let pos = 0; + for (;;) { + const idx = lower.indexOf(q, pos); + if (idx === -1) break; + for (let i = idx; i < idx + q.length; i++) set.add(i); + pos = idx + 1; + } + return set; +} + +export function fmtTime(sec: number): string { + const m = Math.floor(sec / 60); + const s = sec % 60; + return `${String(m).padStart(2, '0')}:${s.toFixed(1).padStart(4, '0')}`; +} + +export function fmtMs(ms: number): string { + const sec = ms / 1000; + const m = Math.floor(sec / 60); + const s = sec % 60; + return `${String(m).padStart(2, '0')}:${s.toFixed(2).padStart(5, '0')}`; +} + +function buildChars(text: string, rawText: string, timestamps: number[][]): CharTiming[] { + const chars: CharTiming[] = []; + let ri = 0; + for (let i = 0; i < text.length; i++) { + if (ri < rawText.length && text[i] === rawText[ri]) { + const ts = timestamps[ri]; + chars.push({ char: text[i], start: ts?.[0] ?? -1, end: ts?.[1] ?? -1 }); + ri++; + } else { + chars.push({ char: text[i], start: -1, end: -1 }); + } + } + return chars; +} diff --git a/training/smart-turn-zh/viewer/src/audio.ts b/training/smart-turn-zh/viewer/src/lib/audio.ts similarity index 96% rename from training/smart-turn-zh/viewer/src/audio.ts rename to training/smart-turn-zh/viewer/src/lib/audio.ts index 554e766..60edb51 100644 --- a/training/smart-turn-zh/viewer/src/audio.ts +++ b/training/smart-turn-zh/viewer/src/lib/audio.ts @@ -87,7 +87,6 @@ export class AudioStore { const nch = this.info.channels; const levels: LODLevel[] = []; - // First level: bucket size 256 const B0 = 256; const n0 = Math.ceil(frames / B0); const min0 = new Float32Array(n0); @@ -118,7 +117,6 @@ export class AudioStore { } levels.push({ min: min0, max: max0, bucketSize: B0 }); - // Coarser levels: each bucket = 4 from previous while (levels[levels.length - 1].min.length > 512) { const prev = levels[levels.length - 1]; const F = 4; @@ -149,7 +147,6 @@ function parseWavHeader(buffer: ArrayBuffer): WavInfo { const sampleRate = view.getUint32(24, true); const bitsPerSample = view.getUint16(34, true); - // Search for 'data' chunk let offset = 12; while (offset < buffer.byteLength - 8) { const id = String.fromCharCode( @@ -165,7 +162,7 @@ function parseWavHeader(buffer: ArrayBuffer): WavInfo { return { channels, sampleRate, bitsPerSample, dataOffset, frames }; } offset += 8 + size; - if (offset % 2 !== 0) offset++; // WAV chunks are word-aligned + if (offset % 2 !== 0) offset++; } throw new Error('No data chunk found in WAV file'); } diff --git a/training/smart-turn-zh/viewer/src/timeline.ts b/training/smart-turn-zh/viewer/src/lib/timeline.ts similarity index 84% rename from training/smart-turn-zh/viewer/src/timeline.ts rename to training/smart-turn-zh/viewer/src/lib/timeline.ts index ccf9d0a..a540389 100644 --- a/training/smart-turn-zh/viewer/src/timeline.ts +++ b/training/smart-turn-zh/viewer/src/lib/timeline.ts @@ -43,22 +43,28 @@ export class Timeline { } pan(deltaSec: number) { - const span = this.viewEnd - this.viewStart; this.setView(this.viewStart + deltaSec, this.viewEnd + deltaSec); } - /** Convert time to x pixel position within width. */ timeToX(t: number, width: number): number { return ((t - this.viewStart) / (this.viewEnd - this.viewStart)) * width; } - /** Convert x pixel position to time. */ xToTime(x: number, width: number): number { return this.viewStart + (x / width) * (this.viewEnd - this.viewStart); } - onUpdate(fn: () => void) { + /** Fire listeners without changing state. Used by the playback loop. */ + flush() { + this.emit(); + } + + onUpdate(fn: () => void): () => void { this.listeners.push(fn); + return () => { + const idx = this.listeners.indexOf(fn); + if (idx >= 0) this.listeners.splice(idx, 1); + }; } private emit() { diff --git a/training/smart-turn-zh/viewer/src/vad.ts b/training/smart-turn-zh/viewer/src/lib/vad.ts similarity index 95% rename from training/smart-turn-zh/viewer/src/vad.ts rename to training/smart-turn-zh/viewer/src/lib/vad.ts index 7a5fdf8..d121294 100644 --- a/training/smart-turn-zh/viewer/src/vad.ts +++ b/training/smart-turn-zh/viewer/src/lib/vad.ts @@ -4,7 +4,7 @@ export class VADRenderer { probs: Float32Array | null = null; entryThreshold = 0.3; exitThreshold = 0.1; - readonly frameSec = 0.032; // 32 ms per frame + readonly frameSec = 0.032; private ctx: CanvasRenderingContext2D; @@ -41,14 +41,12 @@ export class VADRenderer { const startFrame = Math.max(0, Math.floor(vStart / frameSec) - 1); const endFrame = Math.min(probs.length, Math.ceil(tl.viewEnd / frameSec) + 1); - // Compute hysteresis state up to startFrame let active = false; for (let i = 0; i < startFrame; i++) { if (!active && probs[i] >= this.entryThreshold) active = true; else if (active && probs[i] <= this.exitThreshold) active = false; } - // Draw active/inactive regions let regStart = startFrame; let regActive = active; @@ -73,7 +71,6 @@ export class VADRenderer { } fillRegion(regStart, endFrame, regActive); - // Probability curve ctx.strokeStyle = '#4fc3f7'; ctx.lineWidth = 1; ctx.beginPath(); @@ -87,11 +84,9 @@ export class VADRenderer { } ctx.stroke(); - // Threshold lines this.drawThresh(w, h, this.entryThreshold, '#ff9800', 'Entry'); this.drawThresh(w, h, this.exitThreshold, '#f44336', 'Exit'); - // Cursor const cx = tl.timeToX(tl.cursor, w); if (cx >= 0 && cx <= w) { ctx.strokeStyle = '#ff5722'; diff --git a/training/smart-turn-zh/viewer/src/waveform.ts b/training/smart-turn-zh/viewer/src/lib/waveform.ts similarity index 90% rename from training/smart-turn-zh/viewer/src/waveform.ts rename to training/smart-turn-zh/viewer/src/lib/waveform.ts index 64357f7..a182cfd 100644 --- a/training/smart-turn-zh/viewer/src/waveform.ts +++ b/training/smart-turn-zh/viewer/src/lib/waveform.ts @@ -4,7 +4,7 @@ import type { AudioStore } from './audio'; export type WaveformScale = 'linear' | 'dB'; export class WaveformRenderer { - channel = -1; // -1 = merged all channels + channel = -1; scale: WaveformScale = 'dB'; private ctx: CanvasRenderingContext2D; @@ -33,7 +33,6 @@ export class WaveformRenderer { ctx.setTransform(dpr, 0, 0, dpr, 0, 0); ctx.clearRect(0, 0, w, h); - // Center line ctx.strokeStyle = '#333'; ctx.lineWidth = 0.5; ctx.beginPath(); @@ -41,7 +40,6 @@ export class WaveformRenderer { ctx.lineTo(w, h / 2); ctx.stroke(); - // dB grid lines if (this.scale === 'dB') { const mid = h / 2, amp = mid * 0.95; ctx.font = '9px monospace'; @@ -64,7 +62,7 @@ export class WaveformRenderer { const sr = audio.sampleRate; const s0 = Math.floor(tl.viewStart * sr); const s1 = Math.ceil(tl.viewEnd * sr); - const spp = (s1 - s0) / w; // samples per pixel + const spp = (s1 - s0) / w; if (spp <= 1) { this.drawRaw(w, h, s0, s1); @@ -72,7 +70,6 @@ export class WaveformRenderer { this.drawLOD(w, h, s0, s1, spp); } - // Playback cursor const cx = tl.timeToX(tl.cursor, w); if (cx >= 0 && cx <= w) { ctx.strokeStyle = '#ff5722'; @@ -84,14 +81,12 @@ export class WaveformRenderer { } } - /** Map a linear amplitude [-1,1] to vertical position. */ private mapY(v: number, mid: number, amp: number): number { if (this.scale === 'dB') { const sign = v < 0 ? -1 : 1; const abs = Math.abs(v); - // -60 dB floor, map to 0..1 const db = abs > 1e-6 ? 20 * Math.log10(abs) : -60; - const norm = Math.max(0, (db + 60) / 60); // 0 at -60dB, 1 at 0dB + const norm = Math.max(0, (db + 60) / 60); return mid - sign * norm * amp; } return mid - v * amp; @@ -115,7 +110,6 @@ export class WaveformRenderer { const levels = this.audio.getLOD(this.channel); if (!levels.length) return; - // Pick level where bucketSize <= samplesPerPixel let lv = levels[0]; for (const l of levels) { if (l.bucketSize <= spp) lv = l; @@ -129,7 +123,6 @@ export class WaveformRenderer { ctx.fillStyle = '#4fc3f7'; ctx.beginPath(); - // Forward pass: max envelope for (let x = 0; x < w; x++) { const ss = s0 + (x / w) * span; const se = ss + span / w; @@ -141,7 +134,6 @@ export class WaveformRenderer { const y = this.mapY(hi, mid, amp); x === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y); } - // Backward pass: min envelope for (let x = w - 1; x >= 0; x--) { const ss = s0 + (x / w) * span; const se = ss + span / w; diff --git a/training/smart-turn-zh/viewer/src/main.ts b/training/smart-turn-zh/viewer/src/main.ts deleted file mode 100644 index e3e27c2..0000000 --- a/training/smart-turn-zh/viewer/src/main.ts +++ /dev/null @@ -1,439 +0,0 @@ -import { Timeline } from './timeline'; -import { AudioStore } from './audio'; -import { WaveformRenderer, type WaveformScale } from './waveform'; -import { VADRenderer } from './vad'; -import { ASRPanel } from './asr'; -import './style.css'; - -// --- State --- - -const tl = new Timeline(); -const audio = new AudioStore(); - -// --- DOM --- - -const $ = (id: string) => document.getElementById(id) as T; - -const multiInput = $('multi-input'); -const wavStatus = $('wav-status'); -const vadStatus = $('vad-status'); -const asrStatus = $('asr-status'); -const chSel = $('channel-select'); -const playBtn = $('play-btn'); -const timeDisp = $('time-display'); -const wfCanvas = $('waveform-canvas'); -const vadCanvas = $('vad-canvas'); -const mmCanvas = $('minimap-canvas'); -const searchIn = $('search-input'); -const prevBtn = $('prev-btn'); -const nextBtn = $('next-btn'); -const vadEntry = $('vad-entry'); -const vadExit = $('vad-exit'); -const dropEl = $('drop-overlay'); - -// --- Renderers --- - -const wf = new WaveformRenderer(wfCanvas, tl, audio); -const vad = new VADRenderer(vadCanvas, tl); -const asr = new ASRPanel($('asr-panel'), tl); - -// --- Playback --- - -let actx: AudioContext | null = null; -let srcNode: AudioBufferSourceNode | null = null; -let gainNode: GainNode | null = null; -let playing = false; -let playT0 = 0; -let playOff = 0; -let playBuf: AudioBuffer | null = null; -let playChannel = -1; -let gainValue = 10.0; -const gainSlider = $('gain-slider'); -const gainDisp = $('gain-value'); - -function ensurePlayBuf(ch: number): AudioBuffer | null { - if (playBuf && playChannel === ch) return playBuf; - playBuf = audio.createAudioBuffer(ch); - playChannel = ch; - return playBuf; -} - -function play(offset: number) { - if (!audio.raw) return; - const buf = ensurePlayBuf(wf.channel); - if (!buf) return; - actx = new AudioContext({ sampleRate: audio.sampleRate }); - gainNode = actx.createGain(); - gainNode.gain.value = gainValue; - gainNode.connect(actx.destination); - srcNode = actx.createBufferSource(); - srcNode.buffer = buf; - srcNode.connect(gainNode); - srcNode.start(0, offset); - srcNode.onended = () => stop(); - playT0 = actx.currentTime; - playOff = offset; - playing = true; - playBtn.innerHTML = '▮▮'; - rafLoop(); -} - -function stop() { - if (srcNode) { - srcNode.onended = null; - try { srcNode.stop(); } catch { /* already stopped */ } - srcNode = null; - } - if (actx) { - tl.cursor = curTime(); - actx.close(); - actx = null; - } - playing = false; - playBtn.innerHTML = '▶'; - renderAll(); -} - -function curTime(): number { - if (!actx) return tl.cursor; - return playOff + (actx.currentTime - playT0); -} - -function rafLoop() { - if (!playing) return; - const t = curTime(); - if (t >= tl.duration) { stop(); return; } - tl.cursor = t; - // Auto-scroll when cursor exits viewport - if (t > tl.viewEnd) { - const span = tl.viewEnd - tl.viewStart; - tl.viewStart = t; - tl.viewEnd = t + span; - } - renderAll(); - requestAnimationFrame(rafLoop); -} - -// --- File loading --- - -multiInput.onchange = () => { - for (const f of multiInput.files ?? []) routeFile(f); -}; - -function routeFile(f: File) { - if (f.name.endsWith('.wav')) loadWav(f); - else if (f.name.endsWith('.npy')) loadVad(f); - else if (f.name.endsWith('.json')) loadAsr(f); -} - -async function loadWav(f: File) { - wavStatus.textContent = '...'; - try { - await audio.load(f); - tl.sampleRate = audio.sampleRate; - tl.setDuration(audio.duration); - chSel.innerHTML = ''; - for (let i = 0; i < audio.channelCount; i++) { - chSel.innerHTML += ``; - } - chSel.disabled = false; - playBtn.disabled = false; - playBuf = null; - wavStatus.textContent = '\u2713'; - } catch (e) { - wavStatus.textContent = '\u2717'; - console.error(e); - } -} - -async function loadVad(f: File) { - vadStatus.textContent = '...'; - try { - vad.load(await f.arrayBuffer()); - vadStatus.textContent = '\u2713'; - renderAll(); - } catch (e) { - vadStatus.textContent = '\u2717'; - console.error(e); - } -} - -async function loadAsr(f: File) { - asrStatus.textContent = '...'; - try { - const json = JSON.parse(await f.text()); - asr.load(Array.isArray(json) ? json : [json]); - asrStatus.textContent = '\u2713'; - prevBtn.disabled = false; - nextBtn.disabled = false; - } catch (e) { - asrStatus.textContent = '\u2717'; - console.error(e); - } -} - -// --- Drag & drop --- - -document.ondragover = (e) => { e.preventDefault(); dropEl.hidden = false; }; -dropEl.ondragleave = () => { dropEl.hidden = true; }; -document.ondrop = (e) => { - e.preventDefault(); - dropEl.hidden = true; - for (const f of e.dataTransfer?.files ?? []) routeFile(f); -}; - -// --- Controls --- - -chSel.onchange = () => { - wf.channel = +chSel.value; - playBuf = null; - renderAll(); -}; - -playBtn.onclick = () => playing ? stop() : play(tl.cursor); - -gainSlider.oninput = () => { - gainValue = +gainSlider.value; - gainDisp.textContent = `${gainValue.toFixed(1)}x`; - if (gainNode) gainNode.gain.value = gainValue; -}; - -vadEntry.oninput = () => { vad.entryThreshold = +vadEntry.value; renderAll(); }; -vadExit.oninput = () => { vad.exitThreshold = +vadExit.value; renderAll(); }; - -// Waveform scale toggle -$('wf-scale').onclick = (e) => { - const btn = (e.target as HTMLElement).closest('.scale-btn') as HTMLElement | null; - if (!btn) return; - wf.scale = btn.dataset.scale as WaveformScale; - for (const b of $('wf-scale').querySelectorAll('.scale-btn')) b.classList.remove('active'); - btn.classList.add('active'); - renderAll(); -}; - -// Zoom level presets -$('zoom-levels').onclick = (e) => { - const btn = (e.target as HTMLElement).closest('.zoom-btn') as HTMLElement | null; - if (!btn) return; - const span = +btn.dataset.span!; - if (span === 0) { - tl.setView(0, tl.duration); - } else { - const center = (tl.viewStart + tl.viewEnd) / 2; - tl.setView(center - span / 2, center + span / 2); - } - for (const b of $('zoom-levels').querySelectorAll('.zoom-btn')) b.classList.remove('active'); - btn.classList.add('active'); - renderAll(); -}; - -searchIn.oninput = () => { asr.search(searchIn.value); renderAll(); }; -prevBtn.onclick = () => { asr.prev(); renderAll(); }; -nextBtn.onclick = () => { asr.next(); renderAll(); }; - -// ASR click to seek (character-level or sentence-level) -$('transcript-list').onclick = (e) => { - const el = (e.target as HTMLElement).closest('.sentence') as HTMLElement | null; - if (!el) return; - const sentIdx = +el.dataset.idx!; - - // Character click: seek to that character's time - const charEl = (e.target as HTMLElement).closest('.char') as HTMLElement | null; - const t = charEl ? +charEl.dataset.cs! / 1000 : +el.dataset.start! / 1000; - - // Zoom to fit the sentence - asr.zoomToSentence(sentIdx); - tl.setCursor(t); - if (playing) { stop(); play(t); } - renderAll(); -}; - -// --- Canvas interaction (pan / zoom / seek) --- - -for (const cvs of [wfCanvas, vadCanvas]) { - cvs.addEventListener('wheel', (e) => { - e.preventDefault(); - if (e.metaKey || e.ctrlKey) { - // Cmd/Ctrl + scroll = zoom - const rect = cvs.getBoundingClientRect(); - const frac = (e.clientX - rect.left) / rect.width; - tl.zoom(e.deltaY > 0 ? 1.25 : 0.8, frac); - } else { - // Plain scroll = horizontal pan - const span = tl.viewEnd - tl.viewStart; - tl.pan((e.deltaY > 0 ? 0.15 : -0.15) * span); - } - }, { passive: false }); - - let drag = false, startX = 0, startVS = 0, moved = false; - - cvs.onmousedown = (e) => { - drag = true; moved = false; startX = e.clientX; startVS = tl.viewStart; - }; - window.addEventListener('mousemove', (e) => { - if (!drag) return; - const dx = e.clientX - startX; - if (Math.abs(dx) > 3) moved = true; - if (!moved) return; - const rect = cvs.getBoundingClientRect(); - const span = tl.viewEnd - tl.viewStart; - const dt = -(dx / rect.width) * span; - tl.setView(startVS + dt, startVS + dt + span); - }); - window.addEventListener('mouseup', (e) => { - if (!drag) return; - drag = false; - if (!moved) { - const rect = cvs.getBoundingClientRect(); - const t = tl.xToTime(e.clientX - rect.left, rect.width); - tl.setCursor(t); - if (playing) { stop(); play(t); } - } - }); -} - -// Minimap click to navigate -mmCanvas.onclick = (e) => { - const rect = mmCanvas.getBoundingClientRect(); - const frac = (e.clientX - rect.left) / rect.width; - const t = frac * tl.duration; - const span = tl.viewEnd - tl.viewStart; - tl.setView(t - span / 2, t + span / 2); -}; - -// --- Keyboard shortcuts --- - -document.onkeydown = (e) => { - // Let search input handle its own keys (except Escape) - if (e.target === searchIn && e.key !== 'Escape') { - if (e.key === 'Enter') { - e.preventDefault(); - e.shiftKey ? asr.prev() : asr.next(); - renderAll(); - } - return; - } - switch (e.key) { - case ' ': - e.preventDefault(); - playing ? stop() : play(tl.cursor); - break; - case 'f': - e.preventDefault(); - searchIn.focus(); - break; - case 'Escape': - searchIn.blur(); - break; - case '=': case '+': - tl.zoom(0.67, 0.5); - break; - case '-': - tl.zoom(1.5, 0.5); - break; - case 'ArrowLeft': - tl.pan(-(tl.viewEnd - tl.viewStart) * 0.1); - break; - case 'ArrowRight': - tl.pan((tl.viewEnd - tl.viewStart) * 0.1); - break; - case '0': - wf.channel = -1; chSel.value = '-1'; playBuf = null; renderAll(); - break; - default: - if (e.key >= '1' && e.key <= '9') { - const ch = +e.key - 1; - if (ch < audio.channelCount) { - wf.channel = ch; chSel.value = String(ch); playBuf = null; renderAll(); - } - } - } -}; - -// --- Render --- - -function renderAll() { - wf.render(); - vad.render(); - renderMinimap(); - - // ASR overlays on waveform canvas - if (asr.sentences.length) { - const dpr = devicePixelRatio; - const w = wfCanvas.width / dpr; - const h = wfCanvas.height / dpr; - const ctx = wfCanvas.getContext('2d')!; - ctx.setTransform(dpr, 0, 0, dpr, 0, 0); - if (asr.results.length) asr.drawOverlay(ctx, w, h); - asr.drawLabels(ctx, w, h); - } - - // Karaoke highlight - asr.highlightAt(tl.cursor * 1000); - - timeDisp.textContent = `${fmt(tl.cursor)} / ${fmt(tl.duration)}`; -} - -function renderMinimap() { - if (!audio.raw) return; - const dpr = devicePixelRatio; - const rect = mmCanvas.getBoundingClientRect(); - mmCanvas.width = rect.width * dpr; - mmCanvas.height = rect.height * dpr; - const ctx = mmCanvas.getContext('2d')!; - const w = rect.width, h = rect.height; - ctx.setTransform(dpr, 0, 0, dpr, 0, 0); - ctx.clearRect(0, 0, w, h); - - // Coarsest LOD waveform overview - const levels = audio.getLOD(wf.channel); - if (levels.length) { - const lv = levels[levels.length - 1]; - const mid = h / 2, amp = mid; - ctx.fillStyle = '#1e3a4a'; - ctx.beginPath(); - for (let x = 0; x < w; x++) { - const b = Math.min(Math.floor((x / w) * lv.max.length), lv.max.length - 1); - x === 0 ? ctx.moveTo(x, mid - lv.max[b] * amp) : ctx.lineTo(x, mid - lv.max[b] * amp); - } - for (let x = w - 1; x >= 0; x--) { - const b = Math.min(Math.floor((x / w) * lv.min.length), lv.min.length - 1); - ctx.lineTo(x, mid - lv.min[b] * amp); - } - ctx.closePath(); - ctx.fill(); - } - - // Viewport indicator - const x1 = (tl.viewStart / tl.duration) * w; - const x2 = (tl.viewEnd / tl.duration) * w; - ctx.fillStyle = 'rgba(79,195,247,0.15)'; - ctx.fillRect(x1, 0, x2 - x1, h); - ctx.strokeStyle = '#4fc3f7'; - ctx.lineWidth = 1; - ctx.strokeRect(x1 + 0.5, 0.5, x2 - x1 - 1, h - 1); -} - -function fmt(sec: number): string { - const m = Math.floor(sec / 60); - const s = sec % 60; - return `${String(m).padStart(2, '0')}:${s.toFixed(1).padStart(4, '0')}`; -} - -// --- Timeline update listener (batched via rAF) --- - -let renderPending = false; -tl.onUpdate(() => { - if (playing) return; // playback loop handles rendering - if (renderPending) return; - renderPending = true; - requestAnimationFrame(() => { renderPending = false; renderAll(); }); -}); - -// --- Resize --- - -const ro = new ResizeObserver(() => { wf.resize(); vad.resize(); renderAll(); }); -ro.observe(wfCanvas.parentElement!); -ro.observe(vadCanvas.parentElement!); -wf.resize(); -vad.resize(); diff --git a/training/smart-turn-zh/viewer/src/main.tsx b/training/smart-turn-zh/viewer/src/main.tsx new file mode 100644 index 0000000..5057455 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/main.tsx @@ -0,0 +1,5 @@ +import { createRoot } from 'react-dom/client'; +import { App } from './App'; +import './style.css'; + +createRoot(document.getElementById('root')!).render(); diff --git a/training/smart-turn-zh/viewer/tsconfig.json b/training/smart-turn-zh/viewer/tsconfig.json index 6b4064d..d2cad1e 100644 --- a/training/smart-turn-zh/viewer/tsconfig.json +++ b/training/smart-turn-zh/viewer/tsconfig.json @@ -3,6 +3,7 @@ "target": "ES2022", "module": "ESNext", "moduleResolution": "bundler", + "jsx": "react-jsx", "strict": true, "isolatedModules": true, "esModuleInterop": true, diff --git a/training/smart-turn-zh/viewer/vite.config.ts b/training/smart-turn-zh/viewer/vite.config.ts index 4eb250e..000221e 100644 --- a/training/smart-turn-zh/viewer/vite.config.ts +++ b/training/smart-turn-zh/viewer/vite.config.ts @@ -1,5 +1,7 @@ import { defineConfig } from 'vite'; +import react from '@vitejs/plugin-react'; export default defineConfig({ + plugins: [react()], build: { outDir: 'dist' }, }); From 9e32c8885db69997d85e48d26b54c153bd4a375f Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 15:08:48 +1200 Subject: [PATCH 24/36] feat: add spectrogram to audio viewer FFT Web Worker with 10s tile caching, mel/linear freq scale toggle (default mel), turbo colormap, and frequency axis labels. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../smart-turn-zh/docs/03-audio-viewer.md | 85 +++-- training/smart-turn-zh/viewer/src/App.tsx | 7 + .../src/components/SpectrogramTrack.tsx | 80 +++++ .../viewer/src/lib/fft-worker.ts | 96 +++++ .../viewer/src/lib/spectrogram.ts | 337 ++++++++++++++++++ training/smart-turn-zh/viewer/src/style.css | 4 + 6 files changed, 574 insertions(+), 35 deletions(-) create mode 100644 training/smart-turn-zh/viewer/src/components/SpectrogramTrack.tsx create mode 100644 training/smart-turn-zh/viewer/src/lib/fft-worker.ts create mode 100644 training/smart-turn-zh/viewer/src/lib/spectrogram.ts diff --git a/training/smart-turn-zh/docs/03-audio-viewer.md b/training/smart-turn-zh/docs/03-audio-viewer.md index 1d97be7..93a1be6 100644 --- a/training/smart-turn-zh/docs/03-audio-viewer.md +++ b/training/smart-turn-zh/docs/03-audio-viewer.md @@ -68,24 +68,37 @@ trivial — read the header to get length, then wrap the remaining bytes as a ``` viewer/ -├── index.html # single entry point +├── index.html ├── src/ -│ ├── main.ts # bootstrap, file loading, layout -│ ├── audio.ts # WAV decode, channel extraction, LOD cache -│ ├── waveform.ts # Canvas waveform renderer -│ ├── spectrogram.ts # Canvas spectrogram renderer (FFT in Worker) -│ ├── vad.ts # .npy parser + VAD curve renderer -│ ├── asr.ts # ASR JSON loader + transcript panel + search -│ ├── timeline.ts # shared time axis, zoom/pan state, cursor sync -│ └── fft-worker.ts # Web Worker for spectrogram computation +│ ├── main.tsx # React bootstrap +│ ├── App.tsx # root component, file loading, keyboard shortcuts +│ ├── style.css # dark theme, responsive layout +│ ├── lib/ +│ │ ├── audio.ts # WAV decode, channel extraction, LOD pyramid +│ │ ├── waveform.ts # Canvas waveform renderer +│ │ ├── vad.ts # .npy parser + VAD curve renderer +│ │ ├── asr.ts # ASR JSON loader + search + overlay drawing +│ │ ├── timeline.ts # shared time axis, zoom/pan state, cursor sync +│ │ ├── spectrogram.ts # tile-cached spectrogram renderer + colormap +│ │ └── fft-worker.ts # Web Worker for STFT computation +│ ├── components/ +│ │ ├── Toolbar.tsx # file controls, channel selector, playback +│ │ ├── WaveformTrack.tsx # waveform canvas + ASR label overlays +│ │ ├── VADTrack.tsx # VAD canvas + threshold inputs +│ │ ├── SpectrogramTrack.tsx # spectrogram canvas (FFT tiles) +│ │ ├── ASRPanel.tsx # search bar + transcript list +│ │ └── Minimap.tsx # overview bar with viewport indicator +│ └── hooks/ +│ ├── usePlayback.ts # Web Audio API playback, gain, auto-scroll +│ └── useCanvasInteraction.ts # wheel zoom, drag pan, click-to-seek ├── package.json ├── tsconfig.json └── vite.config.ts ``` -**Stack**: TypeScript + Vite (dev server + build). No framework — vanilla DOM -for the panels, Canvas 2D for all visualizations. Keeps the bundle tiny and -avoids framework overhead on large data. +**Stack**: React 19 + TypeScript + Vite. Canvas 2D for all visualizations. +React manages component state and layout; rendering libraries (`waveform.ts`, +`vad.ts`, `asr.ts`) draw directly to canvas refs. ## Performance Strategy @@ -191,33 +204,35 @@ time spans on the timeline canvas. ## Implementation Phases -### Phase 1 — Scaffold + waveform +### Phase 1 — Scaffold + waveform ✅ -- Vite project setup, HTML shell, file drop zone. -- WAV decode via `AudioContext.decodeAudioData`. -- LOD pyramid builder (Web Worker). -- Canvas waveform renderer with pan/zoom. -- Channel selector (individual + "All" merged view). -- Audio playback with seek. +- [x] Vite project setup, HTML shell, file drop zone. +- [x] WAV decode via `AudioContext.decodeAudioData`. +- [x] LOD pyramid builder (main thread, 4× decimation levels). +- [x] Canvas waveform renderer with pan/zoom. +- [x] Channel selector (individual + "All" merged view). +- [x] Audio playback with seek. -### Phase 2 — VAD + ASR +### Phase 2 — VAD + ASR ✅ -- `.npy` parser (typed array). -- VAD probability canvas, synced to waveform timeline. -- Threshold line (draggable or input). -- ASR JSON loader, transcript panel. -- Click sentence to seek. +- [x] `.npy` parser (typed array). +- [x] VAD probability canvas, synced to waveform timeline. +- [x] Entry/exit threshold inputs with hysteresis logic. +- [x] ASR JSON loader, transcript panel. +- [x] Click sentence to seek. -### Phase 3 — Search + polish +### Phase 3 — Search + polish ✅ -- ASR text search with highlight on timeline. -- Prev/Next navigation. -- Minimap overview bar. -- Keyboard shortcuts. -- Responsive layout, loading indicators, error handling. +- [x] ASR text search with highlight on timeline. +- [x] Prev/Next navigation. +- [x] Minimap overview bar. +- [x] Keyboard shortcuts. +- [x] Responsive layout, loading indicators, error handling. +- [x] Character-level karaoke highlighting during playback. +- [x] Drag-and-drop file loading. -### Phase 4 — Spectrogram +### Phase 4 — Spectrogram ✅ -- FFT Web Worker with tile caching. -- Spectrogram canvas, synced timeline. -- Color map (e.g. viridis or magma). +- [x] FFT Web Worker with tile caching (10 s tiles, FFT 512 / hop 256). +- [x] Spectrogram canvas, synced timeline, frequency axis labels. +- [x] Color map (magma). diff --git a/training/smart-turn-zh/viewer/src/App.tsx b/training/smart-turn-zh/viewer/src/App.tsx index b73b643..e6626b3 100644 --- a/training/smart-turn-zh/viewer/src/App.tsx +++ b/training/smart-turn-zh/viewer/src/App.tsx @@ -9,6 +9,7 @@ import { import { Toolbar } from './components/Toolbar'; import { WaveformTrack } from './components/WaveformTrack'; import { VADTrack } from './components/VADTrack'; +import { SpectrogramTrack } from './components/SpectrogramTrack'; import { Minimap } from './components/Minimap'; import { ASRPanel } from './components/ASRPanel'; import { usePlayback } from './hooks/usePlayback'; @@ -285,6 +286,12 @@ export function App() { onExitChange={setVadExit} onSeek={handleSeek} /> +
diff --git a/training/smart-turn-zh/viewer/src/components/SpectrogramTrack.tsx b/training/smart-turn-zh/viewer/src/components/SpectrogramTrack.tsx new file mode 100644 index 0000000..735978e --- /dev/null +++ b/training/smart-turn-zh/viewer/src/components/SpectrogramTrack.tsx @@ -0,0 +1,80 @@ +import { useRef, useEffect, useCallback, useState, memo } from 'react'; +import type { Timeline } from '../lib/timeline'; +import type { AudioStore } from '../lib/audio'; +import { SpectrogramRenderer, type FreqScale } from '../lib/spectrogram'; +import { useCanvasInteraction } from '../hooks/useCanvasInteraction'; + +interface SpectrogramTrackProps { + timeline: Timeline; + audio: AudioStore; + channel: number; + onSeek: (t: number) => void; +} + +export const SpectrogramTrack = memo(function SpectrogramTrack({ + timeline, audio, channel, onSeek, +}: SpectrogramTrackProps) { + const canvasRef = useRef(null); + const rendererRef = useRef(null); + const [freqScale, setFreqScale] = useState('mel'); + + const channelRef = useRef(channel); + const freqScaleRef = useRef(freqScale); + channelRef.current = channel; + freqScaleRef.current = freqScale; + + const draw = useCallback(() => { + const r = rendererRef.current; + if (!r) return; + r.channel = channelRef.current; + r.freqScale = freqScaleRef.current; + r.render(); + }, []); + + useEffect(() => { + const canvas = canvasRef.current; + if (!canvas) return; + + const r = new SpectrogramRenderer(canvas, timeline, audio); + rendererRef.current = r; + r.onTileReady = draw; + r.resize(); + draw(); + + const unsub = timeline.onUpdate(draw); + const ro = new ResizeObserver(() => { r.resize(); draw(); }); + ro.observe(canvas.parentElement!); + + return () => { + unsub(); + ro.disconnect(); + r.dispose(); + rendererRef.current = null; + }; + }, [timeline, audio, draw]); + + useEffect(draw, [channel, freqScale, draw]); + + useCanvasInteraction(canvasRef, timeline, onSeek); + + return ( +
+ Spectrogram +
+ + +
+ +
+ ); +}); diff --git a/training/smart-turn-zh/viewer/src/lib/fft-worker.ts b/training/smart-turn-zh/viewer/src/lib/fft-worker.ts new file mode 100644 index 0000000..d0f2a32 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/lib/fft-worker.ts @@ -0,0 +1,96 @@ +/** Web Worker — computes STFT for a single spectrogram tile. */ + +self.onmessage = (e: MessageEvent) => { + const { tileKey, samples, fftSize, hopSize } = e.data as { + tileKey: string; + samples: Float32Array; + fftSize: number; + hopSize: number; + }; + + const freqBins = (fftSize >>> 1) + 1; + const frames = + samples.length >= fftSize + ? Math.floor((samples.length - fftSize) / hopSize) + 1 + : 0; + const magnitudes = new Float32Array(frames * freqBins); + + // Hann window + const win = new Float32Array(fftSize); + for (let i = 0; i < fftSize; i++) { + win[i] = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (fftSize - 1))); + } + + const re = new Float64Array(fftSize); + const im = new Float64Array(fftSize); + + for (let f = 0; f < frames; f++) { + const off = f * hopSize; + for (let i = 0; i < fftSize; i++) { + re[i] = samples[off + i] * win[i]; + im[i] = 0; + } + + fft(re, im); + + const base = f * freqBins; + for (let k = 0; k < freqBins; k++) { + const mag = Math.sqrt(re[k] * re[k] + im[k] * im[k]) / fftSize; + magnitudes[base + k] = 20 * Math.log10(Math.max(mag, 1e-10)); + } + } + + postMessage( + { type: 'result', tileKey, magnitudes, frames, freqBins }, + { transfer: [magnitudes.buffer] }, + ); +}; + +/* ---- Radix-2 Cooley–Tukey FFT (in-place) ---- */ + +function fft(re: Float64Array, im: Float64Array) { + const n = re.length; + + // Bit-reversal permutation + for (let i = 1, j = 0; i < n; i++) { + let bit = n >> 1; + while (j & bit) { + j ^= bit; + bit >>= 1; + } + j ^= bit; + if (i < j) { + let t = re[i]; + re[i] = re[j]; + re[j] = t; + t = im[i]; + im[i] = im[j]; + im[j] = t; + } + } + + // Butterfly stages + for (let len = 2; len <= n; len <<= 1) { + const half = len >> 1; + const ang = (-2 * Math.PI) / len; + const wR = Math.cos(ang); + const wI = Math.sin(ang); + for (let i = 0; i < n; i += len) { + let cR = 1, + cI = 0; + for (let j = 0; j < half; j++) { + const a = i + j, + b = a + half; + const tR = cR * re[b] - cI * im[b]; + const tI = cR * im[b] + cI * re[b]; + re[b] = re[a] - tR; + im[b] = im[a] - tI; + re[a] += tR; + im[a] += tI; + const nR = cR * wR - cI * wI; + cI = cR * wI + cI * wR; + cR = nR; + } + } + } +} diff --git a/training/smart-turn-zh/viewer/src/lib/spectrogram.ts b/training/smart-turn-zh/viewer/src/lib/spectrogram.ts new file mode 100644 index 0000000..c7c8773 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/lib/spectrogram.ts @@ -0,0 +1,337 @@ +import type { Timeline } from './timeline'; +import type { AudioStore } from './audio'; + +/* ---- Mel helpers ---- */ + +function hzToMel(hz: number): number { + return 2595 * Math.log10(1 + hz / 700); +} + +function melToHz(mel: number): number { + return 700 * (10 ** (mel / 2595) - 1); +} + +/* ---- Turbo colormap (256 entries) ---- */ + +const STOPS: [number, number, number, number][] = [ + [0, 0, 0, 10], + [0.1, 20, 10, 120], + [0.2, 30, 80, 200], + [0.3, 0, 160, 230], + [0.4, 0, 210, 170], + [0.5, 50, 220, 80], + [0.6, 140, 210, 20], + [0.7, 210, 180, 0], + [0.8, 250, 130, 0], + [0.9, 240, 50, 0], + [1, 180, 10, 0], +]; + +const CMAP = new Uint8Array(256 * 3); +for (let i = 0; i < 256; i++) { + const t = i / 255; + let si = 0; + for (let s = 1; s < STOPS.length; s++) { + if (STOPS[s][0] >= t) { + si = s - 1; + break; + } + } + const [t0, r0, g0, b0] = STOPS[si]; + const [t1, r1, g1, b1] = STOPS[si + 1]; + const f = (t - t0) / (t1 - t0); + CMAP[i * 3] = Math.round(r0 + (r1 - r0) * f); + CMAP[i * 3 + 1] = Math.round(g0 + (g1 - g0) * f); + CMAP[i * 3 + 2] = Math.round(b0 + (b1 - b0) * f); +} + +/* ---- Renderer ---- */ + +export type FreqScale = 'mel' | 'linear'; + +interface CachedTile { + magnitudes: Float32Array; + frames: number; + freqBins: number; + canvas: HTMLCanvasElement; + scale: FreqScale; + startTime: number; + endTime: number; +} + +export class SpectrogramRenderer { + channel = -1; + freqScale: FreqScale = 'mel'; + dbMin = -80; + dbMax = 0; + + /** Called after a tile finishes computing so the component can redraw. */ + onTileReady: (() => void) | null = null; + + private ctx: CanvasRenderingContext2D; + private worker: Worker; + private cache = new Map(); + private pending = new Set(); + private lastRaw: Int16Array | null = null; + + private readonly fftSize = 512; + private readonly hopSize = 256; + private readonly tileSec = 10; + private readonly maxPending = 20; + + constructor( + private canvas: HTMLCanvasElement, + private tl: Timeline, + private audio: AudioStore, + ) { + this.ctx = canvas.getContext('2d')!; + this.worker = new Worker( + new URL('./fft-worker.ts', import.meta.url), + { type: 'module' }, + ); + this.worker.onmessage = (e) => this.onWorkerMsg(e); + } + + resize() { + const dpr = devicePixelRatio; + const rect = this.canvas.getBoundingClientRect(); + this.canvas.width = rect.width * dpr; + this.canvas.height = rect.height * dpr; + } + + render() { + if (!this.audio.raw) return; + + // Invalidate cache when audio data changes (new file loaded) + if (this.audio.raw !== this.lastRaw) { + this.clearCache(); + this.lastRaw = this.audio.raw; + } + + const { ctx, canvas, tl } = this; + const dpr = devicePixelRatio; + const w = canvas.width / dpr; + const h = canvas.height / dpr; + + ctx.setTransform(dpr, 0, 0, dpr, 0, 0); + ctx.clearRect(0, 0, w, h); + + // Visible tile range + 1-tile margin on each side + const maxTile = Math.ceil(this.audio.duration / this.tileSec); + const t0 = Math.max(0, Math.floor(tl.viewStart / this.tileSec) - 1); + const t1 = Math.min(maxTile, Math.ceil(tl.viewEnd / this.tileSec) + 1); + + for (let ti = t0; ti < t1; ti++) { + const key = `${this.channel}:${ti}`; + const cached = this.cache.get(key); + + if (cached) { + // Rebuild tile canvas if freq scale changed + if (cached.scale !== this.freqScale) { + this.rebuildTileCanvas(cached); + } + + const x0 = tl.timeToX(cached.startTime, w); + const x1 = tl.timeToX(cached.endTime, w); + const left = Math.max(0, x0); + const right = Math.min(w, x1); + if (right > left) { + const srcX = ((left - x0) / (x1 - x0)) * cached.canvas.width; + const srcW = ((right - left) / (x1 - x0)) * cached.canvas.width; + ctx.drawImage( + cached.canvas, + srcX, 0, srcW, cached.canvas.height, + left, 0, right - left, h, + ); + } + } else if (!this.pending.has(key) && this.pending.size < this.maxPending) { + this.requestTile(ti); + } + } + + this.drawFreqAxis(w, h); + + // Cursor + const cx = tl.timeToX(tl.cursor, w); + if (cx >= 0 && cx <= w) { + ctx.strokeStyle = '#ff5722'; + ctx.lineWidth = 1.5; + ctx.beginPath(); + ctx.moveTo(cx, 0); + ctx.lineTo(cx, h); + ctx.stroke(); + } + } + + dispose() { + this.worker.terminate(); + this.cache.clear(); + } + + /* ---- internals ---- */ + + private clearCache() { + this.cache.clear(); + this.pending.clear(); + } + + private requestTile(ti: number) { + const key = `${this.channel}:${ti}`; + this.pending.add(key); + + const sr = this.audio.sampleRate; + const s0 = ti * this.tileSec * sr; + const s1 = Math.min((ti + 1) * this.tileSec * sr, this.audio.totalFrames); + const samples = this.extractSamples(s0, s1); + + this.worker.postMessage( + { + type: 'compute', + tileKey: key, + samples, + fftSize: this.fftSize, + hopSize: this.hopSize, + }, + { transfer: [samples.buffer] }, + ); + } + + private extractSamples(start: number, end: number): Float32Array { + const raw = this.audio.raw!; + const nch = this.audio.channelCount; + const ch = this.channel; + const len = end - start; + const out = new Float32Array(len); + + if (ch === -1) { + for (let i = 0; i < len; i++) { + let sum = 0; + for (let c = 0; c < nch; c++) sum += raw[(start + i) * nch + c]; + out[i] = sum / nch / 32768; + } + } else { + for (let i = 0; i < len; i++) { + out[i] = raw[(start + i) * nch + ch] / 32768; + } + } + return out; + } + + private onWorkerMsg(e: MessageEvent) { + const { tileKey, magnitudes, frames, freqBins } = e.data as { + tileKey: string; + magnitudes: Float32Array; + frames: number; + freqBins: number; + }; + this.pending.delete(tileKey); + if (frames === 0) return; + + const tileCanvas = this.buildTileCanvas(magnitudes, frames, freqBins); + + const ti = parseInt(tileKey.split(':')[1]); + const startTime = ti * this.tileSec; + const endTime = Math.min(startTime + this.tileSec, this.audio.duration); + + this.cache.set(tileKey, { + magnitudes, frames, freqBins, + canvas: tileCanvas, + scale: this.freqScale, + startTime, endTime, + }); + this.onTileReady?.(); + } + + /** Build an offscreen canvas from magnitude data using current freqScale. */ + private buildTileCanvas( + magnitudes: Float32Array, frames: number, freqBins: number, + ): HTMLCanvasElement { + const img = this.buildImageData(magnitudes, frames, freqBins, this.freqScale); + const oc = document.createElement('canvas'); + oc.width = frames; + oc.height = freqBins; + oc.getContext('2d')!.putImageData(img, 0, 0); + return oc; + } + + /** Rebuild an existing tile's canvas when freq scale changes. */ + private rebuildTileCanvas(tile: CachedTile) { + const img = this.buildImageData( + tile.magnitudes, tile.frames, tile.freqBins, this.freqScale, + ); + tile.canvas.getContext('2d')!.putImageData(img, 0, 0); + tile.scale = this.freqScale; + } + + /** Convert magnitude grid to RGBA ImageData with mel or linear freq mapping. */ + private buildImageData( + magnitudes: Float32Array, frames: number, freqBins: number, scale: FreqScale, + ): ImageData { + const img = new ImageData(frames, freqBins); + const px = img.data; + const range = this.dbMax - this.dbMin; + const nyquist = this.audio.sampleRate / 2; + const melMax = scale === 'mel' ? hzToMel(nyquist) : 0; + + for (let row = 0; row < freqBins; row++) { + // Map output row to a (possibly fractional) FFT bin index + let k: number; + if (scale === 'mel') { + const mel = (row / (freqBins - 1)) * melMax; + const hz = melToHz(mel); + k = (hz / nyquist) * (freqBins - 1); + } else { + k = row; + } + + const k0 = Math.floor(k); + const k1 = Math.min(k0 + 1, freqBins - 1); + const frac = k - k0; + const y = freqBins - 1 - row; // flip: low freq at bottom + + for (let f = 0; f < frames; f++) { + const base = f * freqBins; + const db = magnitudes[base + k0] * (1 - frac) + magnitudes[base + k1] * frac; + const norm = Math.max(0, Math.min(1, (db - this.dbMin) / range)); + const ci = Math.round(norm * 255) * 3; + const pi = (y * frames + f) * 4; + px[pi] = CMAP[ci]; + px[pi + 1] = CMAP[ci + 1]; + px[pi + 2] = CMAP[ci + 2]; + px[pi + 3] = 255; + } + } + + return img; + } + + private drawFreqAxis(w: number, h: number) { + const { ctx } = this; + const nyquist = this.audio.sampleRate / 2; + const freqs = [500, 1000, 2000, 4000, 6000, 8000].filter((f) => f <= nyquist); + + ctx.font = '9px monospace'; + ctx.textBaseline = 'middle'; + ctx.textAlign = 'right'; + + for (const freq of freqs) { + let y: number; + if (this.freqScale === 'mel') { + y = h * (1 - hzToMel(freq) / hzToMel(nyquist)); + } else { + y = h * (1 - freq / nyquist); + } + + ctx.strokeStyle = 'rgba(255,255,255,0.1)'; + ctx.lineWidth = 0.5; + ctx.beginPath(); + ctx.moveTo(0, y); + ctx.lineTo(w, y); + ctx.stroke(); + + ctx.fillStyle = 'rgba(255,255,255,0.3)'; + const label = freq >= 1000 ? `${freq / 1000}k` : `${freq}`; + ctx.fillText(label, w - 4, y); + } + } +} diff --git a/training/smart-turn-zh/viewer/src/style.css b/training/smart-turn-zh/viewer/src/style.css index 465be6b..06f8155 100644 --- a/training/smart-turn-zh/viewer/src/style.css +++ b/training/smart-turn-zh/viewer/src/style.css @@ -166,6 +166,10 @@ button:disabled { max-height: 120px; } +#spectrogram-track { + min-height: 120px; +} + .scale-toggle { position: absolute; top: 4px; From 8e0d6655ccfb24b7468c231bf7309f96e273f2b4 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 15:27:55 +1200 Subject: [PATCH 25/36] feat: add resizable panels and right-side ASR layout Move ASR panel to right side, add drag-to-resize handles between tracks and on ASR panel edge, persist layout in localStorage. Co-Authored-By: Claude Opus 4.6 (1M context) --- training/smart-turn-zh/viewer/src/App.tsx | 145 +++++++++++++----- .../viewer/src/components/ASRPanel.tsx | 2 +- .../viewer/src/components/ResizeHandle.tsx | 41 +++++ training/smart-turn-zh/viewer/src/style.css | 49 +++++- 4 files changed, 196 insertions(+), 41 deletions(-) create mode 100644 training/smart-turn-zh/viewer/src/components/ResizeHandle.tsx diff --git a/training/smart-turn-zh/viewer/src/App.tsx b/training/smart-turn-zh/viewer/src/App.tsx index e6626b3..e51038a 100644 --- a/training/smart-turn-zh/viewer/src/App.tsx +++ b/training/smart-turn-zh/viewer/src/App.tsx @@ -10,6 +10,7 @@ import { Toolbar } from './components/Toolbar'; import { WaveformTrack } from './components/WaveformTrack'; import { VADTrack } from './components/VADTrack'; import { SpectrogramTrack } from './components/SpectrogramTrack'; +import { ResizeHandle } from './components/ResizeHandle'; import { Minimap } from './components/Minimap'; import { ASRPanel } from './components/ASRPanel'; import { usePlayback } from './hooks/usePlayback'; @@ -44,6 +45,70 @@ export function App() { // Drop overlay const [showDrop, setShowDrop] = useState(false); + // ---- Layout persistence & resize handlers ---- + + const LAYOUT_KEY = 'viewer-layout'; + + const [resizeTrack] = useState(() => { + const ids = ['waveform-track', 'vad-track', 'spectrogram-track']; + const MIN = 30; + + const save = () => { + const els = ids.map((id) => document.getElementById(id)); + const panel = document.getElementById('asr-panel'); + if (els.some((e) => !e) || !panel) return; + const layout = { + trackFlex: els.map((e) => e!.offsetHeight), + asrWidth: panel.offsetWidth, + }; + localStorage.setItem(LAYOUT_KEY, JSON.stringify(layout)); + }; + + const resize = (aboveIdx: number, belowIdx: number) => (delta: number) => { + const els = ids.map((id) => document.getElementById(id)); + if (els.some((e) => !e)) return; + const heights = els.map((e) => e!.offsetHeight); + + heights[aboveIdx] += delta; + heights[belowIdx] -= delta; + if (heights[aboveIdx] < MIN || heights[belowIdx] < MIN) return; + + els.forEach((e, i) => { e!.style.flex = `${heights[i]} 0 0px`; }); + save(); + }; + + return { + wfVad: resize(0, 1), + vadSpec: resize(1, 2), + asr: (delta: number) => { + const panel = document.getElementById('asr-panel'); + if (!panel) return; + panel.style.width = `${Math.max(200, Math.min(600, panel.offsetWidth - delta))}px`; + save(); + }, + }; + }); + + // Restore saved layout on mount + useEffect(() => { + try { + const raw = localStorage.getItem(LAYOUT_KEY); + if (!raw) return; + const layout = JSON.parse(raw) as { trackFlex?: number[]; asrWidth?: number }; + const ids = ['waveform-track', 'vad-track', 'spectrogram-track']; + if (layout.trackFlex?.length === 3) { + ids.forEach((id, i) => { + const el = document.getElementById(id); + if (el) el.style.flex = `${layout.trackFlex![i]} 0 0px`; + }); + } + if (layout.asrWidth) { + const panel = document.getElementById('asr-panel'); + if (panel) panel.style.width = `${layout.asrWidth}px`; + } + } catch { /* ignore corrupt data */ } + }, []); + // Playback const { playing, play, stop, setGain, invalidateBuffer } = usePlayback(tl, audio); @@ -265,50 +330,58 @@ export function App() { onGainChange={handleGainChange} /> -
- +
+
+ + + + + +
+ + +
+ + + + - -
- - - - diff --git a/training/smart-turn-zh/viewer/src/components/ASRPanel.tsx b/training/smart-turn-zh/viewer/src/components/ASRPanel.tsx index 72fdae5..3a05e85 100644 --- a/training/smart-turn-zh/viewer/src/components/ASRPanel.tsx +++ b/training/smart-turn-zh/viewer/src/components/ASRPanel.tsx @@ -131,13 +131,13 @@ export const ASRPanel = memo(function ASRPanel({ } }} /> + {searchCount} + + {ZOOM_PRESETS.map((z, i) => (
diff --git a/training/smart-turn-zh/viewer/src/components/ASRPanel.tsx b/training/smart-turn-zh/viewer/src/components/ASRPanel.tsx index ca9bdba..805143f 100644 --- a/training/smart-turn-zh/viewer/src/components/ASRPanel.tsx +++ b/training/smart-turn-zh/viewer/src/components/ASRPanel.tsx @@ -15,12 +15,13 @@ interface ASRPanelProps { onNext: () => void; onPrev: () => void; onSeek: (time: number) => void; + onPlaySegment: (start: number, end: number) => void; playing: boolean; } export const ASRPanel = memo(function ASRPanel({ timeline, sentences, searchQuery, searchResults, searchResultIdx, - onSearchChange, onNext, onPrev, onSeek, playing, + onSearchChange, onNext, onPrev, onSeek, onPlaySegment, playing, }: ASRPanelProps) { const listRef = useRef(null); const activeCharRef = useRef(null); @@ -189,7 +190,11 @@ export const ASRPanel = memo(function ASRPanel({ return (
- {fmtTime(s.start / 1000)} + { e.stopPropagation(); onPlaySegment(s.start / 1000, s.end / 1000); }} + title={`Play ${fmtTime(s.start / 1000)} \u2013 ${fmtTime(s.end / 1000)}`} + >{fmtTime(s.start / 1000)} {s.chars.map((c, ci) => { const hl = hlSet?.has(ci) ? ' search-hl' : ''; diff --git a/training/smart-turn-zh/viewer/src/hooks/usePlayback.ts b/training/smart-turn-zh/viewer/src/hooks/usePlayback.ts index bdb4321..43bd645 100644 --- a/training/smart-turn-zh/viewer/src/hooks/usePlayback.ts +++ b/training/smart-turn-zh/viewer/src/hooks/usePlayback.ts @@ -15,9 +15,11 @@ export function usePlayback(timeline: Timeline, audio: AudioStore) { const gainValueRef = useRef(10.0); const playingRef = useRef(false); const rafIdRef = useRef(0); + const segmentEndRef = useRef(0); const stop = useCallback(() => { playingRef.current = false; + segmentEndRef.current = 0; cancelAnimationFrame(rafIdRef.current); if (srcRef.current) { @@ -76,7 +78,8 @@ export function usePlayback(timeline: Timeline, audio: AudioStore) { const a = actxRef.current; if (!a) return; const t = playOffRef.current + (a.currentTime - playT0Ref.current); - if (t >= timeline.duration) { stopRef.current(); return; } + const endAt = segmentEndRef.current; + if (t >= timeline.duration || (endAt > 0 && t >= endAt)) { stopRef.current(); return; } timeline.cursor = t; // Auto-scroll when cursor exits viewport if (t > timeline.viewEnd) { @@ -90,6 +93,11 @@ export function usePlayback(timeline: Timeline, audio: AudioStore) { rafIdRef.current = requestAnimationFrame(loop); }, [audio, timeline]); + const playSegment = useCallback((start: number, end: number, channel: number) => { + segmentEndRef.current = end; + play(start, channel); + }, [play]); + const setGain = useCallback((value: number) => { gainValueRef.current = value; if (gainNodeRef.current) gainNodeRef.current.gain.value = value; @@ -112,5 +120,5 @@ export function usePlayback(timeline: Timeline, audio: AudioStore) { }; }, []); - return { playing, play, stop, setGain, invalidateBuffer }; + return { playing, play, playSegment, stop, setGain, invalidateBuffer }; } diff --git a/training/smart-turn-zh/viewer/src/style.css b/training/smart-turn-zh/viewer/src/style.css index fc66723..b523176 100644 --- a/training/smart-turn-zh/viewer/src/style.css +++ b/training/smart-turn-zh/viewer/src/style.css @@ -372,11 +372,12 @@ button:disabled { } .sentence { - padding: 5px 12px; + padding: 6px 12px; cursor: pointer; display: flex; + align-items: baseline; gap: 8px; - line-height: 1.5; + line-height: 1.6; transition: background var(--transition); border-left: 2px solid transparent; } @@ -406,7 +407,42 @@ button:disabled { font-size: 11px; flex-shrink: 0; min-width: 55px; - padding-top: 2px; + padding: 2px 6px; + position: relative; + cursor: pointer; + border-radius: 4px; + transition: background 0.15s; + text-align: center; +} + +.sentence .time:hover { + background: var(--accent-muted); +} + +.sentence .time::after { + content: '\25B6'; + position: absolute; + inset: 0; + display: flex; + align-items: center; + justify-content: center; + font-size: 14px; + color: var(--accent); + background: var(--accent-muted); + border-radius: 4px; + opacity: 0; + transform: scale(0.7); + transition: opacity 0.15s, transform 0.15s; + pointer-events: none; +} + +.sentence .time:hover::after { + opacity: 1; + transform: scale(1); +} + +.sentence .time:active::after { + transform: scale(0.85); } .sentence .txt { From 8c8b01d01881a25b10d0a6914e3b3ab5074a7b53 Mon Sep 17 00:00:00 2001 From: Eason WaveKat Date: Mon, 20 Apr 2026 19:43:42 +1200 Subject: [PATCH 30/36] feat: add direct waveform rendering and view span label Add pixel-perfect waveform rendering for views up to ~25s by computing per-pixel min/max from raw samples. Show current view time range in zoom controls toolbar. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../viewer/src/components/Toolbar.tsx | 10 ++++++ .../smart-turn-zh/viewer/src/lib/waveform.ts | 36 +++++++++++++++++++ training/smart-turn-zh/viewer/src/style.css | 7 ++++ 3 files changed, 53 insertions(+) diff --git a/training/smart-turn-zh/viewer/src/components/Toolbar.tsx b/training/smart-turn-zh/viewer/src/components/Toolbar.tsx index cd72b42..b1d2272 100644 --- a/training/smart-turn-zh/viewer/src/components/Toolbar.tsx +++ b/training/smart-turn-zh/viewer/src/components/Toolbar.tsx @@ -35,6 +35,7 @@ export const Toolbar = memo(function Toolbar({ gainValue, onGainChange, }: ToolbarProps) { const timeRef = useRef(null); + const spanRef = useRef(null); const [activeZoom, setActiveZoom] = useState(null); // Update time display imperatively (60fps during playback) @@ -43,6 +44,13 @@ export const Toolbar = memo(function Toolbar({ if (timeRef.current) { timeRef.current.textContent = `${fmtTime(timeline.cursor)} / ${fmtTime(timeline.duration)}`; } + if (spanRef.current) { + const s = timeline.viewEnd - timeline.viewStart; + spanRef.current.textContent = s < 1 ? `${(s * 1000) | 0}ms` + : s < 60 ? `${s.toFixed(1)}s` + : s < 3600 ? `${(s / 60).toFixed(1)}m` + : `${(s / 3600).toFixed(1)}h`; + } }; update(); return timeline.onUpdate(update); @@ -99,6 +107,8 @@ export const Toolbar = memo(function Toolbar({ {z.label} ))} + + view
Date: Mon, 20 Apr 2026 20:29:05 +1200 Subject: [PATCH 33/36] feat: add VAD block navigation and shortcuts dialog Co-Authored-By: Claude Opus 4.6 (1M context) --- training/smart-turn-zh/viewer/src/App.tsx | 54 ++++++++++++- .../viewer/src/components/ShortcutsDialog.tsx | 35 ++++++++ .../viewer/src/components/Toolbar.tsx | 5 ++ .../viewer/src/components/VADTrack.tsx | 43 ++++++++-- training/smart-turn-zh/viewer/src/lib/vad.ts | 46 ++++++++++- training/smart-turn-zh/viewer/src/style.css | 79 +++++++++++++++++++ 6 files changed, 249 insertions(+), 13 deletions(-) create mode 100644 training/smart-turn-zh/viewer/src/components/ShortcutsDialog.tsx diff --git a/training/smart-turn-zh/viewer/src/App.tsx b/training/smart-turn-zh/viewer/src/App.tsx index c7c0bec..06cbd59 100644 --- a/training/smart-turn-zh/viewer/src/App.tsx +++ b/training/smart-turn-zh/viewer/src/App.tsx @@ -6,6 +6,7 @@ import { type Sentence, parseSentences, searchSentences, zoomToSentence, } from './lib/asr'; +import { parseNpy, findVADBlocks, nextVADBlock, prevVADBlock } from './lib/vad'; import { Toolbar } from './components/Toolbar'; import { WaveformTrack } from './components/WaveformTrack'; import { VADTrack } from './components/VADTrack'; @@ -13,6 +14,7 @@ import { SpectrogramTrack } from './components/SpectrogramTrack'; import { ResizeHandle } from './components/ResizeHandle'; import { Minimap } from './components/Minimap'; import { ASRPanel } from './components/ASRPanel'; +import { ShortcutsDialog } from './components/ShortcutsDialog'; import { usePlayback } from './hooks/usePlayback'; export function App() { @@ -32,7 +34,7 @@ export function App() { const [gainValue, setGainValue] = useState(10.0); // VAD state - const [vadBuffer, setVadBuffer] = useState(null); + const [vadProbs, setVadProbs] = useState(null); const [vadEntry, setVadEntry] = useState(0.3); const [vadExit, setVadExit] = useState(0.1); @@ -45,6 +47,9 @@ export function App() { // Drop overlay const [showDrop, setShowDrop] = useState(false); + // Shortcuts dialog + const [showShortcuts, setShowShortcuts] = useState(false); + // ---- Layout persistence & resize handlers ---- const LAYOUT_KEY = 'viewer-layout'; @@ -134,6 +139,14 @@ export function App() { searchResultsRef.current = searchResults; searchIdxRef.current = searchIdx; + // VAD refs for keyboard nav + const vadProbsRef = useRef(vadProbs); + const vadEntryRef = useRef(vadEntry); + const vadExitRef = useRef(vadExit); + vadProbsRef.current = vadProbs; + vadEntryRef.current = vadEntry; + vadExitRef.current = vadExit; + // ---- Handlers ---- const handleSeek = useCallback((t: number) => { @@ -192,7 +205,8 @@ export function App() { const loadVad = useCallback(async (f: File) => { setVadStatus('...'); try { - setVadBuffer(await f.arrayBuffer()); + const buf = await f.arrayBuffer(); + setVadProbs(parseNpy(buf)); setVadStatus('\u2713'); } catch (e) { setVadStatus('\u2717'); @@ -308,6 +322,35 @@ export function App() { case 'ArrowRight': tl.pan((tl.viewEnd - tl.viewStart) * 0.1); break; + case '[': { + const probs = vadProbsRef.current; + if (probs) { + const blocks = findVADBlocks(probs, 0.032, vadEntryRef.current, vadExitRef.current); + const b = prevVADBlock(blocks, tl.cursor); + if (b) { + handleSeek(b.start); + const span = tl.viewEnd - tl.viewStart; + tl.setView(b.start - span * 0.2, b.start - span * 0.2 + span); + } + } + break; + } + case ']': { + const probs = vadProbsRef.current; + if (probs) { + const blocks = findVADBlocks(probs, 0.032, vadEntryRef.current, vadExitRef.current); + const b = nextVADBlock(blocks, tl.cursor); + if (b) { + handleSeek(b.start); + const span = tl.viewEnd - tl.viewStart; + tl.setView(b.start - span * 0.2, b.start - span * 0.2 + span); + } + } + break; + } + case '?': + setShowShortcuts(v => !v); + break; case '0': handleChannelChange(-1); break; @@ -320,7 +363,7 @@ export function App() { }; document.addEventListener('keydown', onKeyDown); return () => document.removeEventListener('keydown', onKeyDown); - }, [tl, audio, handlePlayToggle, handleChannelChange]); + }, [tl, audio, handlePlayToggle, handleChannelChange, handleSeek]); // ---- Render ---- @@ -340,6 +383,7 @@ export function App() { onPlayToggle={handlePlayToggle} gainValue={gainValue} onGainChange={handleGainChange} + onShowShortcuts={() => setShowShortcuts(true)} />
@@ -359,7 +403,7 @@ export function App() {
+ + {showShortcuts && setShowShortcuts(false)} />}
); } diff --git a/training/smart-turn-zh/viewer/src/components/ShortcutsDialog.tsx b/training/smart-turn-zh/viewer/src/components/ShortcutsDialog.tsx new file mode 100644 index 0000000..c5e7564 --- /dev/null +++ b/training/smart-turn-zh/viewer/src/components/ShortcutsDialog.tsx @@ -0,0 +1,35 @@ +import { memo } from 'react'; + +const SHORTCUTS = [ + { key: 'Space', desc: 'Play / pause (or replay loop)' }, + { key: 'F', desc: 'Focus search' }, + { key: 'Escape', desc: 'Clear loop / blur input' }, + { key: '+ / −', desc: 'Zoom in / out' }, + { key: '← / →', desc: 'Pan left / right' }, + { key: '[ / ]', desc: 'Previous / next VAD block' }, + { key: 'Shift + drag', desc: 'Select loop range' }, + { key: '0', desc: 'All channels' }, + { key: '1–9', desc: 'Select channel' }, + { key: '?', desc: 'Toggle this dialog' }, +]; + +export const ShortcutsDialog = memo(function ShortcutsDialog({ onClose }: { onClose: () => void }) { + return ( +
+
e.stopPropagation()}> +
+ Keyboard Shortcuts + +
+
+ {SHORTCUTS.map(s => ( +
+ {s.key} + {s.desc} +
+ ))} +
+
+
+ ); +}); diff --git a/training/smart-turn-zh/viewer/src/components/Toolbar.tsx b/training/smart-turn-zh/viewer/src/components/Toolbar.tsx index 7c33c67..ed77967 100644 --- a/training/smart-turn-zh/viewer/src/components/Toolbar.tsx +++ b/training/smart-turn-zh/viewer/src/components/Toolbar.tsx @@ -4,6 +4,8 @@ import { fmtTime } from '../lib/asr'; const ZOOM_PRESETS = [ { label: '1s', span: 1 }, + { label: '5s', span: 5 }, + { label: '10s', span: 10 }, { label: '20s', span: 20 }, { label: '1m', span: 80 }, { label: '5m', span: 300 }, @@ -25,6 +27,7 @@ interface ToolbarProps { onPlayToggle: () => void; gainValue: number; onGainChange: (v: number) => void; + onShowShortcuts: () => void; } export const Toolbar = memo(function Toolbar({ @@ -33,6 +36,7 @@ export const Toolbar = memo(function Toolbar({ channelCount, channel, onChannelChange, playing, canPlay, onPlayToggle, gainValue, onGainChange, + onShowShortcuts, }: ToolbarProps) { const timeRef = useRef(null); const spanRef = useRef(null); @@ -154,6 +158,7 @@ export const Toolbar = memo(function Toolbar({ {gainValue.toFixed(1)}x --:-- / --:-- +
); diff --git a/training/smart-turn-zh/viewer/src/components/VADTrack.tsx b/training/smart-turn-zh/viewer/src/components/VADTrack.tsx index dc2b4f8..9156f14 100644 --- a/training/smart-turn-zh/viewer/src/components/VADTrack.tsx +++ b/training/smart-turn-zh/viewer/src/components/VADTrack.tsx @@ -1,11 +1,11 @@ -import { useRef, useEffect, useCallback, memo } from 'react'; +import { useRef, useEffect, useCallback, useMemo, memo } from 'react'; import type { Timeline } from '../lib/timeline'; -import { VADRenderer } from '../lib/vad'; +import { VADRenderer, findVADBlocks, nextVADBlock, prevVADBlock } from '../lib/vad'; import { useCanvasInteraction } from '../hooks/useCanvasInteraction'; interface VADTrackProps { timeline: Timeline; - vadBuffer: ArrayBuffer | null; + vadProbs: Float32Array | null; entryThreshold: number; exitThreshold: number; onEntryChange: (v: number) => void; @@ -14,7 +14,7 @@ interface VADTrackProps { } export const VADTrack = memo(function VADTrack({ - timeline, vadBuffer, entryThreshold, exitThreshold, + timeline, vadProbs, entryThreshold, exitThreshold, onEntryChange, onExitChange, onSeek, }: VADTrackProps) { const canvasRef = useRef(null); @@ -49,24 +49,51 @@ export const VADTrack = memo(function VADTrack({ return () => { unsub(); ro.disconnect(); rendererRef.current = null; }; }, [timeline, draw]); - // Load VAD data when buffer changes + // Load VAD data when probs change useEffect(() => { - if (vadBuffer && rendererRef.current) { - rendererRef.current.load(vadBuffer); + if (vadProbs && rendererRef.current) { + rendererRef.current.probs = vadProbs; draw(); } - }, [vadBuffer, draw]); + }, [vadProbs, draw]); // Redraw on threshold changes useEffect(draw, [entryThreshold, exitThreshold, draw]); useCanvasInteraction(canvasRef, timeline, onSeek); + const blocks = useMemo( + () => vadProbs ? findVADBlocks(vadProbs, 0.032, entryThreshold, exitThreshold) : [], + [vadProbs, entryThreshold, exitThreshold], + ); + + const handlePrev = useCallback(() => { + const b = prevVADBlock(blocks, timeline.cursor); + if (b) { + onSeek(b.start); + const span = timeline.viewEnd - timeline.viewStart; + timeline.setView(b.start - span * 0.2, b.start - span * 0.2 + span); + } + }, [blocks, timeline, onSeek]); + + const handleNext = useCallback(() => { + const b = nextVADBlock(blocks, timeline.cursor); + if (b) { + onSeek(b.start); + const span = timeline.viewEnd - timeline.viewStart; + timeline.setView(b.start - span * 0.2, b.start - span * 0.2 + span); + } + }, [blocks, timeline, onSeek]); + return (
VAD
+
+ + +